#include <stdio.h>
#include "JZsdk_FileSystm.h"
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>  
#include <math.h>
#include <sys/types.h>  
#include <sys/stat.h>  
#include "JZsdkLib.h"
#include <dirent.h>
#include <errno.h>

/*
*       用于运行指令
*
*/
T_JZsdkReturnCode JZsdk_RunSystemCmd(char *systemCmd)
{
    //FILE *fp;

    //printf("JZsdk_RunSystemCmd:%s\n",systemCmd);

    // fp = popen(systemCmd, "r");
    // if (fp == NULL) {
    //     return -1;
    // }

    int status = system(systemCmd);
    if (status == -1 || WIFEXITED(status) == false) {
        printf("Call %s error, status = %d\n", systemCmd, status);
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    if (WEXITSTATUS(status) == 0) {
        JZSDK_LOG_DEBUG("指令执行成功%s\n",systemCmd);
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    } 
    else {
        JZSDK_LOG_ERROR("指令执行失败Exit status is = %d", WEXITSTATUS(status));
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    //pclose(fp);

    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}

/*

    运行命令 并读取返回值

*/
T_JZsdkReturnCode JZsdk_RunSystemCmd_ReturnResult(char *systemCmd, unsigned int *result)
{
    FILE *fp;
    double temp = 0;

    fp = popen(systemCmd, "r");  
    if (fp == NULL) {  
        printf("Failed to run command\n");  
    }
  
    // 读取并转换时长（这里假设ffprobe的输出只有一行）  
    if (fscanf(fp, "%lf", &temp) != 1) 
    {  
        pclose(fp);  
        printf("Failed to read duration\n");   
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }  
    
    pclose(fp);

    *result = (unsigned int)ceil(temp);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/*

    运行命令 并读取返回值

*/
T_JZsdkReturnCode JZsdk_RunSystemCmd_ReturnResult_Str(char *systemCmd, unsigned char *str)
{
    FILE *fp;
    double temp = 0;

    fp = popen(systemCmd, "r");  
    if (fp == NULL) {  
        printf("Failed to run command\n"); 
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 
    }
  
   // 读取命令的输出  
    while (fgets(str, sizeof(str)-1, fp) != NULL) 
    {  
        printf("%s", str);
    }  
    
    pclose(fp);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/**********************************
 * 
 *  创建一个文件夹
    函数名：JZsdk_check_file_exists
    参数：文件路径
    返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件存在，
    JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件不存在
 * *******************************/
T_JZsdkReturnCode JZsdk_Osal_Mkdir(const char *filePath) 
{  
    int32_t ret;  
 
    if (filePath == NULL) {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  
 
    ret = mkdir(filePath, S_IRWXU);  
    if (ret < 0) {  
        switch (errno) {  
            case EACCES:  
                JZSDK_LOG_ERROR("Permission denied\n");  
                break;  
            case EEXIST:  
                JZSDK_LOG_ERROR("Directory already exists\n");  
                break;  
            case ENOENT:  
                JZSDK_LOG_ERROR("A component of the path does not exist or is a dangling symbolic link\n");  
                break;  
            case ENOMEM:  
                JZSDK_LOG_ERROR("Not enough memory\n");  
                break;  
            case ENOTDIR:  
                JZSDK_LOG_ERROR("A component of the path prefix is not a directory\n");  
                break;  
            case EROFS:  
                JZSDK_LOG_ERROR("The named file resides on a read-only file system\n");  
                break;  
            default:  
                JZSDK_LOG_ERROR("Unknown error %d\n", errno);  
        }  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }  
 
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
}


/**********************************
 * 
 *  文件是否存在判断函数
*   判断文件是否存在
    函数名：JZsdk_check_file_exists
    参数：文件路径
    返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件存在，
    JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件不存在
 * *******************************/
T_JZsdkReturnCode JZsdk_check_file_exists(const char* file_path)   
{  
    if (access(file_path, F_OK) == 0)   
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
    }  
    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
}

/**********************************
 * 
 *  文件夹是否存在判断函数
*   判断文件是否存在
    函数名：JZsdk_check_file_exists
    参数：文件路径
    返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件存在，
    JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件不存在
 * *******************************/
T_JZsdkReturnCode JZsdk_check_directory_exists_posix(const char* directory_path)   
{  
    struct stat st;  
    if (stat(directory_path, &st) == 0 && S_ISDIR(st.st_mode))   
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
    }  
    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
}

/**********************************
 * 
 *  创建新的文件
    函数名：JZsdk_check_file_exists
    参数：文件路径
    返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件存在，
    JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件不存在
 * *******************************/
T_JZsdkReturnCode JZsdk_create_file(const char* file_path) 
{
    FILE* file = fopen(file_path, "w");
    if (file != NULL) 
    {
        fclose(file);
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}

/**********************************
 * 
 *  删除文件
    函数名：JZsdk_delete_file
    参数：文件路径
    返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件已经不存在
    JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件仍然存在
 * *******************************/
T_JZsdkReturnCode JZsdk_delete_file(const char* file_path) 
{
    int remove_result = remove(file_path);  
    if (remove_result != 0) {  
        // 删除失败，返回错误  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }  
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 删除成功  
}

/**********************************
 * 
 *  复制文件
    函数名：JZsdk_copy_file
    参数：文件路径
    返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件已经不存在
    JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件仍然存在
 * *******************************/  
T_JZsdkReturnCode JZsdk_copy_file_byC(const char* source_path, const char* dest_path) 
{  
    FILE *source_file = fopen(source_path, "rb"); // 以二进制读模式打开源文件  
    if (source_file == NULL) {  
        // 无法打开源文件  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }  
      
    FILE *dest_file = fopen(dest_path, "wb"); // 以二进制写模式打开目标文件  
    if (dest_file == NULL) {  
        // 无法创建或打开目标文件  
        fclose(source_file); // 关闭已打开的源文件  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }  
      
    // 分配缓冲区用于读取和写入文件  
    char buffer[4096]; // 缓冲区大小可以根据需要调整  
    size_t bytes_read;  
      
    // 复制文件内容  
    while ((bytes_read = fread(buffer, 1, sizeof(buffer), source_file)) > 0) {  
        if (fwrite(buffer, 1, bytes_read, dest_file) != bytes_read) {  
            // 写入目标文件失败  
            fclose(source_file); // 关闭已打开的源文件  
            fclose(dest_file); // 关闭已打开的目标文件  
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
        }  
    }  
      
    // 关闭文件  
    fclose(source_file);  
    fclose(dest_file);  
      
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 复制成功  
}  
  

// 删除指定路径下的所有文件（不包括子文件夹）  
// 注意：这个函数不会删除子文件夹，如果您需要删除子文件夹，请添加递归逻辑。
T_JZsdkReturnCode JZsdk_delete_files_in_directory(const char* directory_path) 
{  
    DIR* dir;  
    struct dirent* ent;  
    char file_path[1024]; // 假设文件路径不会超过这个长度  
    T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
  
    if ((dir = opendir(directory_path)) != NULL) {  
        while ((ent = readdir(dir)) != NULL) {  
            // 跳过目录条目 '.' 和 '..'  
            if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0) {  
                continue;  
            }  
  
            // 构建文件的完整路径  
            snprintf(file_path, sizeof(file_path), "%s/%s", directory_path, ent->d_name);  
  
            // 如果是文件，则删除它  
            if (remove(file_path) != 0) {  
                perror("remove"); // 打印错误信息  
                ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
                break; // 或者您可以继续并尝试删除其他文件  
            }  
        }  
        closedir(dir);  
    } else {  
        perror("opendir"); // 打印错误信息  
        ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }  
  
    return ret;  
}  

/**********************************
 * 
 *  创建硬链接的函数
    函数名：JZsdk_create_hardlink 
    参数：文件路径 链接路径
    返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示成功
    JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示失败
 * *******************************/  
T_JZsdkReturnCode JZsdk_create_hardlink(const char* target_path, const char* link_path) 
{  
    int result = link(target_path, link_path);  
    if (result == -1) {  
        JZSDK_LOG_ERROR("hardlink"); // 打印错误信息  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 返回错误代码  
    }  
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 返回成功代码  
} 
  

/**********************************
 * 
 *  字符串后缀对比
    函数名：JZsdk_strings_suffix_comparison
    参数：字符串,后缀名
    返回值：
    JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示后缀正确
    JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示后缀错误，或是长度不对
 * *******************************/
T_JZsdkReturnCode JZsdk_strings_suffix_comparison_onlyStr(const unsigned char* Strings, const unsigned char *suffix) 
{
    if (Strings == NULL || suffix == NULL)  
    {  
        JZSDK_LOG_ERROR("字符串后缀对比输入错误");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 如果指针为NULL，返回失败  
    }  

    int suffix_len = (int)strlen((const char*)suffix); // 强制转换为const char*以确保兼容性  
    int Strings_len = (int)strlen((const char*)Strings); // 强制转换为const char*以确保兼容性 

    if (Strings_len <= suffix_len)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 如果字符串长度小于后缀长度，返回失败  
    }

    // 确保不会越界，并且字符串是以空字符结尾的  
    if (memcmp(Strings + Strings_len - suffix_len, suffix, suffix_len) == 0)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
}


/**********************************
 * 
 *  字符串后缀对比
    函数名：JZsdk_strings_suffix_comparison
    参数：字符串, 字符串长度，后缀名
    返回值：
    JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示后缀正确
    JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示后缀错误，或是长度不对
 * *******************************/
T_JZsdkReturnCode JZsdk_strings_suffix_comparison_withLen(const unsigned char* Strings, int Strings_len, const unsigned char *suffix) 
{
    if (Strings == NULL || suffix == NULL)  
    {  
        JZSDK_LOG_ERROR("字符串后缀对比输入错误");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 如果指针为NULL，返回失败  
    }  

    int suffix_len = (int)strlen((const char*)suffix); // 强制转换为const char*以确保兼容性  

    if (Strings_len <= suffix_len)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 如果字符串长度小于后缀长度，返回失败  
    }

    // 确保不会越界，并且字符串是以空字符结尾的  
    if (memcmp(Strings + Strings_len - suffix_len, suffix, suffix_len) == 0)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
}



/**********************************
 * 
 *  读取文件大小
    函数名：JZsdk_Fs_ReadFileSize
    参数：字符串, 字符串长度，后缀名
    返回值：
    JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS读取正确
    JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE读取错误
 * *******************************/
T_JZsdkReturnCode JZsdk_Fs_ReadFileSize(const unsigned char* FilePath, int *FileSize)   
{  
    struct stat statbuf;  
    int result = stat(FilePath, &statbuf);  
  
    if (result == -1) {  
        // 检查 errno 以确定错误原因
        if (errno == EACCES) 
        {
            // 没有读取文件的权限
            JZSDK_LOG_ERROR("无权限");
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        } 
        else if (errno == ENOENT) 
        {
            // 文件不存在
            JZSDK_LOG_ERROR("无文件");
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        } 
        else {
            // 其他错误
            JZSDK_LOG_ERROR("读取错误");
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        }
    }  

    //JZSDK_LOG_DEBUG("%s %d",FilePath, statbuf.st_size);
  
    *FileSize = statbuf.st_size;
  
    if (*FileSize == 0) 
    {  
        // 文件大小为0，可能是空文件  
        JZSDK_LOG_ERROR("文件大小为空");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }  
  
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
}