#include <unistd.h>  // Linux/macOS 下的 mkdir 函数
#include <sys/stat.h> // 补充 Linux 下的文件状态定义
#include "thread_local_logger.h"
#include "AiModule.h"

int cnnProcess(const char* bucket_bytes,const char* object_name_bytes,const char* moduleFileName,const char* moduleFilePath,const char* jsonlUrl) {
	//Py_Initialize();
	//PyRun_SimpleString("print('load so lib!')");
	int alert_count = 0;
    LOG_INFO("load so_code_cnn.so lib");
	PyRun_SimpleString("import so_code_cnn");
    LOG_INFO("load so module so_code_cnn");
	const char *c_json_str = NULL;// 最终的 C 字符串
	PyObject* pModule = PyImport_ImportModule("so_code_cnn");
	if (!pModule) {
		LOG_ERROR("load module so_code_cnn error!");
		PyErr_Print();		
	}
	
    LOG_INFO("get func load");
	
	// 获取函数
	PyObject* pFuncLoad = PyObject_GetAttrString(pModule, "load");
	if (!pFuncLoad || !PyCallable_Check(pFuncLoad)) {
		LOG_ERROR("load function load error!");
		PyErr_Print();
	}
	
    LOG_INFO("prepare args for load");
	// 准备参数
	PyObject* pArgs = PyTuple_New(2);
	PyTuple_SetItem(pArgs, 0, PyUnicode_FromString(moduleFileName));  // 第一个参数
	PyTuple_SetItem(pArgs, 1, PyUnicode_FromString(moduleFilePath));  // 第二个参数

	// 调用函数
	PyObject* pResult = PyObject_CallObject(pFuncLoad, pArgs);
	if (pResult) {
		long loadResult = PyLong_AsLong(pResult);
        LOG_INFO("load result:" , (int)loadResult);
		Py_DECREF(pResult);  // 释放对象
	}	
		
	PyObject* pFuncPredict = PyObject_GetAttrString(pModule, "process_jsonl_and_predict");
	if (!pFuncPredict || !PyCallable_Check(pFuncPredict)) {
		LOG_ERROR("load function process_jsonl_and_predict error!");
		PyErr_Print();
	}
	
	// 准备参数
	PyObject* pArgsPredict = PyTuple_New(1);
	PyTuple_SetItem(pArgsPredict, 0, PyUnicode_FromString(jsonlUrl));  // 第一个参数
	//PyTuple_SetItem(pArgsPredict, 1, PyUnicode_FromString(outputPath));  // 第二个参数

	// 调用函数
	PyObject* pResultPredict = PyObject_CallObject(pFuncPredict, pArgsPredict);
	if (pResultPredict) {
		// 检查是否为字典类型
		if (!PyDict_Check(pResultPredict)) {			
            LOG_ERROR("对象不是字典");
			Py_DECREF(pResultPredict);			
		}else{
			//
			PyObject* pJsonModule = PyImport_ImportModule("json");
			if (!pJsonModule) {
				PyErr_Print();
                LOG_ERROR("加载 json 模块失败");
			}
			
			PyObject* pDumpsFunc = PyObject_GetAttrString(pJsonModule, "dumps");
			if (!pDumpsFunc || !PyCallable_Check(pDumpsFunc)) {
				PyErr_Print();
                LOG_ERROR("获取 json.dumps 函数失败");
			}
			
			PyObject *pDumpsArgs = PyTuple_Pack(1, pResultPredict);
			if (!pDumpsArgs) {
				PyErr_Print();
                LOG_ERROR("构造 json.dumps 参数失败");
			}
			
			PyObject* pJsonStr = PyObject_CallObject(pDumpsFunc, pDumpsArgs);
			Py_DECREF(pDumpsArgs); // 用完参数立即释放
			if (!pJsonStr || !PyUnicode_Check(pJsonStr)) {
				PyErr_Print();		
                LOG_ERROR("json.dumps 序列化失败");		
			}
			
			c_json_str = PyUnicode_AsUTF8(pJsonStr);
			if (!c_json_str) {
				PyErr_Print();
                LOG_ERROR("转换为 C 字符串失败");					
			}
			LOG_DEBUG("bucket:",bucket_bytes,"|object:",object_name_bytes,"|result:",c_json_str);
			//
			PyObject *key_code = PyUnicode_FromString("code");
            PyObject *val_code = PyDict_GetItem(pResultPredict, key_code);
            if (val_code != NULL && PyLong_Check(val_code)) {
                int code = (int)PyLong_AsLong(val_code);  // 转换为 C long
				if(code != 1){
					Py_DECREF(key_code);
			        Py_DECREF(val_code);
					return alert_count;
				}
                
            }

		    PyObject *key_alert_count = PyUnicode_FromString("alert_count");
            PyObject *val_alert_count = PyDict_GetItem(pResultPredict, key_alert_count);
            if (val_alert_count != NULL && PyLong_Check(val_alert_count)) {
                alert_count = (int)PyLong_AsLong(val_alert_count);  // 转换为 C long                
            }
			Py_DECREF(key_alert_count);
			Py_DECREF(val_alert_count);
		}		
	}		

	Py_DECREF(pModule);
	Py_DECREF(pResult);
	Py_DECREF(pResultPredict);
	
	//Py_Finalize();
    return alert_count;
}

int gbmProcess(const char* bucket_bytes,const char* object_name_bytes,const char* moduleFileName,const char* moduleFilePath,const char* jsonlUrl) {
	//Py_Initialize();
	//PyRun_SimpleString("print('load so lib!')");
	int alert_count = 0;
    LOG_INFO("load so_code_gbm.so lib");
	PyRun_SimpleString("import so_code_gbm");
    LOG_INFO("load so module so_code_gbm");
	const char *c_json_str = NULL;// 最终的 C 字符串
	PyObject* pModule = PyImport_ImportModule("so_code_gbm");
	if (!pModule) {
		LOG_ERROR("load module so_code_gbm error!");
		PyErr_Print();
		
	}
	
    LOG_INFO("get function load");
	
	// 获取函数
	PyObject* pFuncLoad = PyObject_GetAttrString(pModule, "load");
	if (!pFuncLoad || !PyCallable_Check(pFuncLoad)) {
		PyErr_Print();
	}
	
    LOG_INFO("prepare args for function load");
	// 准备参数
	PyObject* pArgs = PyTuple_New(2);
	PyTuple_SetItem(pArgs, 0, PyUnicode_FromString(moduleFileName));  // 第一个参数
	PyTuple_SetItem(pArgs, 1, PyUnicode_FromString(moduleFilePath));  // 第二个参数

	// 调用函数
	PyObject* pResult = PyObject_CallObject(pFuncLoad, pArgs);
	if (pResult) {
		long loadResult = PyLong_AsLong(pResult);
        LOG_INFO("load result:" , (int)loadResult);
		Py_DECREF(pResult);  // 释放对象
	}	
		
	PyObject* pFuncPredict = PyObject_GetAttrString(pModule, "lgbm_detect");
	if (!pFuncPredict || !PyCallable_Check(pFuncPredict)) {
		LOG_ERROR("load function lgbm_detect error!");
		PyErr_Print();
	}
	
	// 准备参数
	PyObject* pArgsPredict = PyTuple_New(1);
	PyTuple_SetItem(pArgsPredict, 0, PyUnicode_FromString(jsonlUrl));  // 第一个参数

	// 调用函数
	PyObject* pResultPredict = PyObject_CallObject(pFuncPredict, pArgsPredict);
	if (pResultPredict) {
		// 检查是否为字典类型
		if (!PyDict_Check(pResultPredict)) {			
            LOG_ERROR("对象不是字典");
			Py_DECREF(pResultPredict);			
		}else{
			//
			PyObject* pJsonModule = PyImport_ImportModule("json");
			if (!pJsonModule) {
				PyErr_Print();
                LOG_ERROR("加载 json 模块失败");
			}
			
			PyObject* pDumpsFunc = PyObject_GetAttrString(pJsonModule, "dumps");
			if (!pDumpsFunc || !PyCallable_Check(pDumpsFunc)) {
				PyErr_Print();
                LOG_ERROR("获取 json.dumps 函数失败");
			}
			
			PyObject *pDumpsArgs = PyTuple_Pack(1, pResultPredict);
			if (!pDumpsArgs) {
				PyErr_Print();
                LOG_ERROR("构造 json.dumps 参数失败");
			}
			
			PyObject* pJsonStr = PyObject_CallObject(pDumpsFunc, pDumpsArgs);
			Py_DECREF(pDumpsArgs); // 用完参数立即释放
			if (!pJsonStr || !PyUnicode_Check(pJsonStr)) {
				PyErr_Print();		
                LOG_ERROR("json.dumps 序列化失败");		
			}
			
			c_json_str = PyUnicode_AsUTF8(pJsonStr);
			if (!c_json_str) {
				PyErr_Print();
                LOG_ERROR("转换为 C 字符串失败");					
			}
			LOG_DEBUG("bucket:",bucket_bytes,"|object:",object_name_bytes,"|result:",c_json_str);
			//
			PyObject *key_code = PyUnicode_FromString("code");
            PyObject *val_code = PyDict_GetItem(pResultPredict, key_code);
            if (val_code != NULL && PyLong_Check(val_code)) {
                int code = (int)PyLong_AsLong(val_code);  // 转换为 C long
				if(code != 1){
					Py_DECREF(key_code);
			        Py_DECREF(val_code);
					return alert_count;
				}
                
            }

		    PyObject *key_alert_count = PyUnicode_FromString("alert_count");
            PyObject *val_alert_count = PyDict_GetItem(pResultPredict, key_alert_count);
            if (val_alert_count != NULL && PyLong_Check(val_alert_count)) {
                alert_count = (int)PyLong_AsLong(val_alert_count);  // 转换为 C long	                
            }	
			Py_DECREF(key_alert_count);
			Py_DECREF(val_alert_count);
		}

		
	}		

	Py_DECREF(pModule);
	Py_DECREF(pResult);
	Py_DECREF(pResultPredict);	
	//Py_Finalize();
    return alert_count;
}

int updateGbmProcess(const char* moduleName, const char* jsonlUrl, const char* jsonlContent,char *result_json_str,int threshold) {
	//Py_Initialize();
	//PyRun_SimpleString("print('load so lib!')");
    LOG_INFO("load so lib so_update_gbm");
	PyRun_SimpleString("import so_update_gbm");
    LOG_INFO("load so module so_update_gbm");
	const char *c_json_str = NULL;// 最终的 C 字符串
	PyObject* pModule = PyImport_ImportModule("so_update_gbm");
	if (!pModule) {
		LOG_ERROR("load module so_update_gbm error!");
		PyErr_Print();
		
	}
	
    LOG_INFO("get func update_gbm_model");
	
	// 获取函数		
	PyObject* pFuncUpdate = PyObject_GetAttrString(pModule, "update_gbm_model");
	if (!pFuncUpdate || !PyCallable_Check(pFuncUpdate)) {
		LOG_ERROR("load function update_gbm_model error!");
		PyErr_Print();
	}
	
	// 准备参数
	LOG_INFO("prepare args for function update_gbm_model");
    PyObject* pArgsUpdate = PyTuple_New(4);	
	PyTuple_SetItem(pArgsUpdate, 0, PyUnicode_FromString(moduleName));  // 第一个参数
	PyTuple_SetItem(pArgsUpdate, 1, PyUnicode_FromString(jsonlUrl));  // 第二个参数
	PyTuple_SetItem(pArgsUpdate, 2, PyUnicode_FromString(jsonlContent));  // 第三个参数
	PyTuple_SetItem(pArgsUpdate, 3, PyLong_FromLong(threshold));  // 第四个参数

	// 调用函数
	LOG_INFO("call update_gbm_model");
	PyObject* pResultUpdate = PyObject_CallObject(pFuncUpdate, pArgsUpdate);
	if (pResultUpdate) {
		// 检查是否为字典类型
		if (!PyDict_Check(pResultUpdate)) {			
            LOG_ERROR("对象不是字典");
			Py_DECREF(pResultUpdate);			
		}else{
			//
			PyObject* pJsonModule = PyImport_ImportModule("json");
			if (!pJsonModule) {
				PyErr_Print();
                LOG_ERROR("加载 json 模块失败");
			}
			
			PyObject* pDumpsFunc = PyObject_GetAttrString(pJsonModule, "dumps");
			if (!pDumpsFunc || !PyCallable_Check(pDumpsFunc)) {
				PyErr_Print();
                LOG_ERROR("获取 json.dumps 函数失败");
			}
			
			PyObject *pDumpsArgs = PyTuple_Pack(1, pResultUpdate);
			if (!pDumpsArgs) {
				PyErr_Print();
                LOG_ERROR("构造 json.dumps 参数失败");
			}
			
			PyObject* pJsonStr = PyObject_CallObject(pDumpsFunc, pDumpsArgs);
			Py_DECREF(pDumpsArgs); // 用完参数立即释放
			if (!pJsonStr || !PyUnicode_Check(pJsonStr)) {
				PyErr_Print();		
                LOG_ERROR("json.dumps 序列化失败");		
			}
			
			c_json_str = PyUnicode_AsUTF8(pJsonStr);
			if (!c_json_str) {
				PyErr_Print();
                LOG_ERROR("转换为 C 字符串失败");					
			}
			LOG_DEBUG("输出JSON 结果",c_json_str);
			strcpy(result_json_str, c_json_str);
			//	
		}

		
	}		

	
	//Py_Finalize();
    return 0;
}

int updateCnnProcess(const char* moduleName, const char* jsonlUrl, const char* jsonlContent,char *result_json_str,int max_samples) {
	//Py_Initialize();
	//PyRun_SimpleString("print('load so lib!')");
    LOG_INFO("load so lib so_update_cnn");
	PyRun_SimpleString("import so_update_cnn");
    LOG_INFO("load so module so_update_cnn");
	const char *c_json_str = NULL;// 最终的 C 字符串
	PyObject* pModule = PyImport_ImportModule("so_update_cnn");
	if (!pModule) {
		LOG_ERROR("load module so_update_cnn error!");
		PyErr_Print();
		
	}
	
    LOG_INFO("get func update_cnn_model");
	
	// 获取函数		
	PyObject* pFuncUpdate = PyObject_GetAttrString(pModule, "update_cnn_model");
	if (!pFuncUpdate || !PyCallable_Check(pFuncUpdate)) {
		LOG_ERROR("load function update_cnn_model error!");
		PyErr_Print();
	}
		
	// 准备参数
	LOG_INFO("prepare args");
    PyObject* pArgsUpdate = PyTuple_New(4);	
	PyTuple_SetItem(pArgsUpdate, 0, PyUnicode_FromString(moduleName));  // 第一个参数
	PyTuple_SetItem(pArgsUpdate, 1, PyUnicode_FromString(jsonlUrl));  // 第二个参数
	PyTuple_SetItem(pArgsUpdate, 2, PyUnicode_FromString(jsonlContent));  // 第三个参数
	PyTuple_SetItem(pArgsUpdate, 3, PyLong_FromLong(max_samples));  // 第四个参数    
	
	// 调用函数
	LOG_INFO("call update_cnn_model");
	PyObject* pResultUpdate = PyObject_CallObject(pFuncUpdate, pArgsUpdate);
	if (pResultUpdate) {
		// 检查是否为字典类型
		if (!PyDict_Check(pResultUpdate)) {			
            LOG_ERROR("对象不是字典");
			Py_DECREF(pResultUpdate);			
		}else{
			//
			PyObject* pJsonModule = PyImport_ImportModule("json");
			if (!pJsonModule) {
				PyErr_Print();
                LOG_ERROR("加载 json 模块失败");
			}
			
			PyObject* pDumpsFunc = PyObject_GetAttrString(pJsonModule, "dumps");
			if (!pDumpsFunc || !PyCallable_Check(pDumpsFunc)) {
				PyErr_Print();
                LOG_ERROR("获取 json.dumps 函数失败");
			}
			
			PyObject *pDumpsArgs = PyTuple_Pack(1, pResultUpdate);
			if (!pDumpsArgs) {
				PyErr_Print();
                LOG_ERROR("构造 json.dumps 参数失败");
			}
			
			PyObject* pJsonStr = PyObject_CallObject(pDumpsFunc, pDumpsArgs);
			Py_DECREF(pDumpsArgs); // 用完参数立即释放
			if (!pJsonStr || !PyUnicode_Check(pJsonStr)) {
				PyErr_Print();		
                LOG_ERROR("json.dumps 序列化失败");		
			}
			
			c_json_str = PyUnicode_AsUTF8(pJsonStr);
			if (!c_json_str) {
				PyErr_Print();
                LOG_ERROR("转换为 C 字符串失败");					
			}
			LOG_DEBUG("转JSON 结果",c_json_str);
			strcpy(result_json_str, c_json_str);
			//	
		}

		
	}		

	
	//Py_Finalize();
    return 0;
}