/* 头文件 ------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>

#include "JZsdk_Logger.h"
#include <time.h>
#include "JZsdkLib.h"
#include <pthread.h>
#include <sys/time.h>
#include <sys/resource.h>  
#include <unistd.h>
#include <sys/types.h>  

#define JZSDK_LOG_NAME "JZLOG"
#define JZSDK_LOG_INDEX_FILE_NAME "/root/sdcard/JZLOG/thelast"
#define JZSDK_LOG_PATH "/root/sdcard/JZLOG/"
#define JZSDK_LOG_MAX_COUNT 20
static char logFilePath[128];

#define LOG_GRADE JZSDK_LOGGER_CONSOLE_LOG_LEVEL_INFO 

/* 全局变量 ------------------------------------------------------------------*/
static struct timeval g_start_time;
static FILE *logFile = NULL;
static FILE *logFileCnt = NULL;
static int Logger_init_flag = JZ_FLAGCODE_OFF;

/* 函数声明 ------------------------------------------------------------------*/

long long get_total_ram() {  
    FILE *file;  
    char line[128];  
    long long total_ram = 0;  
  
    file = fopen("/proc/meminfo", "r");  
    if (!file) {  
        perror("Error opening /proc/meminfo");  
        return 0;
    }  
  
    while (fgets(line, sizeof(line), file)) {  
        if (strncmp(line, "MemTotal:", 9) == 0) {  
            sscanf(line, "MemTotal: %lld kB", &total_ram);  
            break;  
        }  
    }  
  
    fclose(file);  
    return total_ram;  
}  
  
long long get_current_rss(pid_t pid) {  
    FILE *file;  
    char line[128];  
    long long vmrss = 0;  
  
    char path[64];  
    snprintf(path, sizeof(path), "/proc/%d/status", pid);  
  
    file = fopen(path, "r");  
    if (!file) {  
        perror("Error opening /proc/[pid]/status");  
        return 0;  
    }  
  
    while (fgets(line, sizeof(line), file)) {  
        if (strncmp(line, "VmRSS:", 6) == 0) {  
            sscanf(line, "VmRSS: %lld kB", &vmrss);  
            break;  
        }  
    }  
  
    fclose(file);  
    return vmrss;  
}

static void *MonitorTask(void *arg)
{
    //获取程序的pid号
    pid_t pid = getpid(); // 获取当前进程的 PID  
    long long total_ram;            //最大ram内存
    long long current_rss;          //RSS内存
    double memory_percentage;       //内存百分比
    
    // 获取系统总 RAM  
    total_ram = get_total_ram();  

    while (1)
    {
        printf("当前进程pid号%d\n",pid);

        // 获取当前进程的内存使用量  
        current_rss = get_current_rss(pid);  
  
        // 计算内存百分比  
        if (total_ram > 0) 
        {  
            memory_percentage = (double)current_rss / total_ram * 100;  
        } else {  
            memory_percentage = 0;  
        }  
  
        // 打印结果  
        printf("Program current memory usage: %lld KB\n", current_rss);  
        JZSDK_LOG_INFO("Monitor:(%.2f%% of total RAM)", memory_percentage);

        delayS(10);
    }
}



static int Log_Monitor()
{
    pthread_t work_mode_task;
	pthread_attr_t task_attribute; //线程属性
	pthread_attr_init(&task_attribute);  //初始化线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED);      //设置线程属性
	int timer = pthread_create(&work_mode_task,&task_attribute,MonitorTask,NULL);		//线程
    if(timer != 0)
    {
        printf("创建计时线程失败！\n");
    }
}

T_JZsdkReturnCode createJZLOGFolder() 
{
    const char *path = "/root/sdcard/JZLOG";

    // 使用系统命令检测路径是否存在
    if(JZsdk_check_directory_exists_posix(path) == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else
    {
        JZsdk_Osal_Mkdir(path);
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
}

int ReadLogNumFromFile() 
{
    const char *path = JZSDK_LOG_INDEX_FILE_NAME;
    int logNum = 0;

    FILE *file = fopen(path, "r");
    if (file == NULL) 
    {
        // 如果文件不存在，则创建并设置LogNum为0
        file = fopen(path, "w");
        fprintf(file, "%d", logNum);
    } 
    else 
    {
        // 从文件中读取LogNum，并自增1
        fscanf(file, "%d", &logNum);
        logNum++;
        fclose(file);

        // 将新的LogNum写回文件中
        file = fopen(path, "w");
        fprintf(file, "%d", logNum);
    }
    fclose(file);

    return logNum;
}

T_JZsdkReturnCode JZsdk_LoggerInit()
{
    int ret;
    unsigned int logFileIndex = 0;
    unsigned int currentLogFileIndex;

    JZsdk_Osal_Mkdir(JZSDK_LOG_PATH);

    char systemCmd[64]; // 用于存储系统命令

    char folderName[JZSDK_FILE_NAME_SIZE_MAX];

    time_t currentTime = time(NULL);
    struct tm *localTime = localtime(&currentTime);

    if (localTime == NULL) {
        printf("Get local time error.\r\n");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    if (access(JZSDK_LOG_NAME, F_OK) != 0) {
        sprintf(folderName, "mkdir %s", JZSDK_LOG_NAME);
        ret = system(folderName);
        if (ret != 0) {
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        }
    }

    logFileCnt = fopen(JZSDK_LOG_INDEX_FILE_NAME, "rb+");
    if (logFileCnt == NULL) 
    {
        logFileCnt = fopen(JZSDK_LOG_INDEX_FILE_NAME, "wb+");
        if (logFileCnt == NULL) 
        {
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        }
    } 
    else 
    {
        ret = fseek(logFileCnt, 0, SEEK_SET);
        if (ret != 0) 
        {
            printf("Seek log count file error, ret: %d\r\n", ret);
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        }

        ret = fread((uint16_t *) &logFileIndex, 1, sizeof(uint16_t), logFileCnt);
        if (ret != sizeof(uint16_t)) 
        {
            printf("Read log file index error.\r\n");
        }
    }

    currentLogFileIndex = logFileIndex;
    logFileIndex++;

    ret = fseek(logFileCnt, 0, SEEK_SET);
    if (ret != 0) 
    {
        printf("Seek log file error, ret: %d\r\n", ret);
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    ret = fwrite((unsigned int *) &logFileIndex, 1, sizeof(unsigned int), logFileCnt);
    if (ret != sizeof(unsigned int)) 
    {
        printf("Write log file index error.\r\n");
        fclose(logFileCnt);
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    fclose(logFileCnt);

    //filePath : /root/sdcard/Logs/_%04d_%04d%02d%02d_%02d-%02d-%02d.log
    sprintf(logFilePath, "%s%04d_%04d%02d%02d_%02d-%02d-%02d.log", JZSDK_LOG_PATH, currentLogFileIndex,
            localTime->tm_year + 1900, localTime->tm_mon + 1, localTime->tm_mday,
            localTime->tm_hour, localTime->tm_min, localTime->tm_sec);

    logFile = fopen(logFilePath, "wb+");
    if (logFile == NULL) 
    {
        printf("Open filepath time error.");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    if (logFileIndex >= JZSDK_LOG_MAX_COUNT) 
    {
        sprintf(systemCmd, "rm -rf %s_%04d*.log", JZSDK_LOG_PATH, currentLogFileIndex - JZSDK_LOG_MAX_COUNT);
        ret = system(systemCmd);
        if (ret != 0) {
            printf("Remove file error, ret:%d.\r\n", ret);
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        }
    }

    sprintf(systemCmd, "ln -sfrv %s " JZSDK_LOG_NAME "/latest.log", logFilePath);
    system(systemCmd);


    //打开初始化完成的flag
    Logger_init_flag = JZ_FLAGCODE_ON;

    //设立监控
    Log_Monitor();

    JZSDK_LOG_INFO("%s", logFilePath);

    JZSDK_LOG_INFO("log初始化完成");

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

T_JZsdkReturnCode JZsdk_LoggerDeInit()
{
    if (logFile != NULL)
    {
        fclose(logFile); 
    }
}

T_JZsdkReturnCode writeToLogFile(const char *data) 
{
    if (logFile == NULL)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    fprintf(logFile, "%s", data); // 写入新的数据
    fflush(logFile);
}

T_JZsdkReturnCode HexToLogFile(const char *data) 
{
    if (logFile == NULL)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    
    fprintf(logFile, "%x ", data[0]); // 写入新的数据
    fflush(logFile);
}


void JZsdk_UserLogOutput(E_JZsdkConsoleLogLevel level, const char *fmt, ...)
{
    // 将日志级别转换为相应的字符串
    const char *JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "";
    switch (level) {
        case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_DEBUG:
            JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "DEBUG";
            break;
        case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_INFO:
            JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "INFO";
            break;
        case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_WARN:
            JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "WARNING";
            break;
        case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_ERROR:
            JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "ERROR";
            break;
        default:
            break;
    }
    // 使用可变参数处理传入的格式化字符串和可变参数
    va_list args;
    va_start(args, fmt);

    //格式化日志消息
    char logMessage[512];
    memset(logMessage, 0, sizeof(logMessage));
    vsnprintf(logMessage, sizeof(logMessage), fmt, args);

    va_end(args);

    struct timeval current_time;
    gettimeofday(&current_time, 0);

    long seconds = current_time.tv_sec - g_start_time.tv_sec;
    long microseconds = current_time.tv_usec - g_start_time.tv_usec;
    double elapsed = seconds + microseconds*1e-6;

    // 执行具体的日志输出操作
    char finalLogMessage[612];
    memset(finalLogMessage, 0, sizeof(finalLogMessage));
    snprintf(finalLogMessage, 612, "[%s][%.4f]%s\n", JZSDK_LOGGER_CONSOLE_LOG_LEVEL, elapsed, logMessage);

    printf("%s",finalLogMessage);

    //写入日志
    if (Logger_init_flag == JZ_FLAGCODE_ON && level <= LOG_GRADE)
    {
        writeToLogFile(finalLogMessage);
    } 
}



void JZsdk_User_OutputHex(E_JZsdkConsoleLogLevel level, const char *fmt, ...)
{
    // 将日志级别转换为相应的字符串
    const char *JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "";
    switch (level) {
        case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_DEBUG:
            JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "DEBUG";
            break;
        case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_INFO:
            JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "INFO";
            break;
        case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_WARN:
            JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "WARNING";
            break;
        case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_ERROR:
            JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "ERROR";
            break;
        default:
            break;
    }
    // 使用可变参数处理传入的格式化字符串和可变参数
    va_list args;
    va_start(args, fmt);

    //格式化日志消息
    char logMessage[10];
    memset(logMessage, 0, sizeof(logMessage));
    vsnprintf(logMessage, sizeof(logMessage), fmt, args);

    va_end(args);

    // 执行具体的日志输出操作
    char finalLogMessage[512];
    memset(finalLogMessage, 0, sizeof(finalLogMessage));
    snprintf(finalLogMessage, 612, "%s", logMessage);


    printf("%x ",finalLogMessage[0]);

    //写入日志
    HexToLogFile(finalLogMessage);
}