#define _CRT_SECURE_NO_WARNINGS
#define EPM_HANDLER_COMMON

#include <tccore/item.h>
#include <tccore/grmtype.h>
#include <tccore/grm.h>
#include <sa/am.h>
#include <tccore/aom.h>
#include <tccore/aom_prop.h>
#include <property/prop_errors.h>
#include <lov/lov_errors.h>
#include <lov/lov.h>
#include <tccore/tctype.h>
#include <res/res_itk.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <string>
#include <vector>
#include <map>
#include <fstream>
#include"kutil.h"
#include <iostream>
#include <map>
#include <vector>
#include <string>
#include "libxl.h"
#include  <io.h>
#include <direct.h>
#include <cfm/cfm.h>
#include <wchar.h>
#include <locale>
#include <codecvt>
#include <chrono>
#include <Windows.h>
#include <thread>
#include <regex>
#include <res\reservation.h>
#include "libxl.h"
#include <map>
#include <fstream>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <filesystem>
#include <sys/stat.h>
#include <iostream>
#include "ado.h"
#include <chrono>
#include <bom/bom.h>

boolean IsRelease(tag_t topLine, char resultString[], vector<char*> referenceValues, char releaseStatus[1024]);
#define DOFREE(obj);


#define MAX_PATH_LENGTH 200
#define MAX_PRINTLINE_LENGTH 400000

std::vector<std::string> split(const std::string& str, const std::string& pattern)
{
	std::vector<std::string> resVec;

	if ("" == str)
	{
		return resVec;
	}
	//方便截取最后一段数据
	std::string strs = str + pattern;

	size_t pos = strs.find(pattern);
	size_t size = strs.size();

	while (pos != std::string::npos)
	{
		std::string x = strs.substr(0, pos);
		resVec.push_back(x);
		strs = strs.substr(pos + pattern.size(), size);
		pos = strs.find(pattern);
	}

	return resVec;
};

bool count(vector<char*> values, char* value)
{
	for (auto referencedValue : values) {
		if (strcmp(referencedValue, value) == 0)
		{
			return true;
		}
	}
	return false;
}
void split(char* src, const char* separator, char** dest, int* num) {

	vector<std::string> resultVector = split(src, separator);
	int count = 0;
	for (auto result : resultVector) {
		int nLen = strlen(result.c_str());
		char* pCh = new char[nLen + 1];
		strcpy(pCh, result.c_str());
		dest[count] = pCh;
		++count;
	}
	*num = count;
}


int XY_ChildIsRelease(EPM_action_message_t msg) {
	printf("=========================判断子件是否全部发布 Start===================\n");
	auto startTime = std::chrono::high_resolution_clock::now();
	//POM_AM__set_application_bypass(true);
	int ifail = ITK_ok;
	int  attachments_num = 0;
	tag_t  rootTask = NULLTAG, * attachments = NULLTAG, user_tag = NULLTAG;
	//获取任务对象
	EPM_ask_root_task(msg.task, &rootTask);
	//获取任务目标对象
	EPM_ask_attachments(rootTask, EPM_target_attachment, &attachments_num, &attachments);

	//获取参数
	char* argflag = NULL, * argvalue = NULL, * arg = NULL, * user_name = NULL;
	char releaseStatus[1024] = "", arg1value[1024] = "", atgltype[1024] = "", atglRev[1024] = "";
	bool isExistRev = false;
	int arg_cnt = TC_number_of_arguments(msg.arguments);
	printf("参数个数为：%d\n", arg_cnt);
	ITKCALL(POM_get_user(&user_name, &user_tag));
	if (arg_cnt > 0)
	{
		for (int i = 0; i < arg_cnt; i++)
		{
			//获取下一个参数（从0开始）
			arg = TC_next_argument(msg.arguments);
			//获取参数的名称和值
			ifail = ITK_ask_argument_named_value((const char*)arg, &argflag, &argvalue);
			if (stricmp(argflag, "releaseStatus") == 0)
			{
				if (argvalue != NULL)
				{
					strcpy(releaseStatus, argvalue);
				}
			}
			else if (stricmp(argflag, "itemType") == 0)
			{
				//strcmp("","");
				if (argvalue != NULL)
				{
					strcpy(arg1value, argvalue);
				}
			}
			else if (stricmp(argflag, "itemChildType") == 0) {
				if (argvalue != NULL)
				{
					strcpy(atgltype, argvalue);
				}
			}
			else if (stricmp(argflag, "itemChildRev") == 0) {
				if (argvalue != NULL)
				{
					strcpy(atglRev, argvalue);
				}
			}
		}
		// 判断条件
		if (strlen(atglRev) > 0) {
			printf("atglRev 不为空\n");
			isExistRev = true;
		}
		else {
			printf("atglRev 为空\n");
		}
	}

	vector<char*> childTypeCheakValues;
	if (strstr(atgltype, ",") != NULL)
	{
		int vectorValueCount = 0;
		char** vectorValueChar = new char* [64];
		split(atgltype, ",", vectorValueChar, &vectorValueCount);
		for (int i = 0; i < vectorValueCount; i++)
		{
			childTypeCheakValues.push_back(vectorValueChar[i]);
		}
	}
	else
	{
		childTypeCheakValues.push_back(atgltype);
	}



	vector<char*> itemTypeValues;
	if (strstr(arg1value, ",") != NULL)
	{
		int vectorValueCount = 0;
		char** vectorValueChar = new char* [64];
		split(arg1value, ",", vectorValueChar, &vectorValueCount);
		for (int i = 0; i < vectorValueCount; i++)
		{
			itemTypeValues.push_back(vectorValueChar[i]);
		}
	}
	else
	{
		itemTypeValues.push_back(arg1value);
	}

	// -referenceValues ==> 需要比对的发布状态；(多值时使用英文,逗号分割)
	vector<char*> referenceValues;
	if (strstr(releaseStatus, ",") != NULL)
	{
		int vectorValueCount = 0;
		char** vectorValueChar = new char* [64];
		split(releaseStatus, ",", vectorValueChar, &vectorValueCount);
		for (int i = 0; i < vectorValueCount; i++)
		{
			referenceValues.push_back(vectorValueChar[i]);
		}
	}
	else
	{
		referenceValues.push_back(releaseStatus);
	}

	// -attrName ==> 流程任务目标下的对象id
	vector<char*> attrName;
	char* itemId = NULL;
	char* itemType = NULL;
	for (int i = 0; i < attachments_num; i++) {

		AOM_ask_value_string(attachments[i], "object_type", &itemType);
		if (isTypeOf(attachments[i], "ItemRevision")) {
			AOM_ask_value_string(attachments[i], "item_id", &itemId);
			attrName.push_back(itemId);
		}
	}
	DOFREE(itemId);
	DOFREE(itemType);


	char resultString[1024] = "";
	for (int i = 0; i < attachments_num; i++)
	{
		char* itemType = NULL;

		AOM_ask_value_string(attachments[i], "object_type", &itemType);
		printf("type_class : %s \r\n", itemType);
		//过滤掉非文件夹的对象
		if (!count(itemTypeValues, itemType))
		{
			DOFREE(itemType);
			continue;
		}
		int viewNum = 0;
		tag_t* viewTag = NULL_TAG;
		//判断是否包含BOM视图
		/*ITKCALL(AOM_ask_value_tags(attachments[i], "structure_revisions", &viewNum, &viewTag));
		if (viewNum <= 0)
		{
			DOFREE(itemType);
			DOFREE(viewTag);
			continue;
		}*/
		//创建BOMWindow
		tag_t top_line = NULLTAG, window = NULLTAG;
		printf("创建BOMWindow\n");
		ITKCALL(BOM_create_window(&window));
		//设置顶层BOM
		printf("设置顶层BOM\n");
		ITKCALL(BOM_set_window_top_line(window, NULLTAG, attachments[i], NULLTAG, &top_line));

		int  count1;
		tag_t* children_line = NULLTAG;
		printf("获取子列BOM\n");
		ITKCALL(BOM_line_ask_all_child_lines(top_line, &count1, &children_line));

		for (int j = 0; j < count1; j++)
		{
			
			tag_t revisions = NULLTAG;
			logical hasPrivilege = false;
			char* item_id = NULL;
			char* item_rev = NULL;
			//判断当前用户是否有权限
			printf("获取子列对应的版本\n");
			ITKCALL(AOM_ask_value_tag(children_line[j], "bl_line_object", &revisions));

			//判断是否在目标关系下 ==> 在目标关系下就可以符合 ==> 为true
			char* objectString = NULL;
			bool ifaaf = false;
			AOM_ask_value_string(revisions, "item_id", &objectString);
			AOM_ask_value_string(revisions, "item_revision_id", &item_rev);
			for (int a = 0; a < attrName.size();a++) {
				char* name = attrName[a];
				if (strcmp(name, objectString)==0) {
					ifaaf = true;
				}
			}

			//判断是否符合版本
			if (isExistRev && strcmp(atglRev, item_rev) != 0) {
				continue;
			}

			//判断是否符合条件
			char* childType = NULL;
			AOM_ask_value_string(revisions, "object_type", &childType);
			if (ifaaf || !count(childTypeCheakValues,childType)) {
				continue;//存在目标中或者不存在于childType检查类型范围内则不判断
			}

			//ITKCALL(AM_check_users_privilege(user_tag, children_line[j], "READ", &hasPrivilege));
			ITKCALL(AOM_ask_value_string(revisions, "item_id", &item_id));
			printf("item_id=%s", item_id);
			printf("获取当前对象对于版本的读权限\n");
			ITKCALL(AM_check_users_privilege(user_tag, revisions, "READ", &hasPrivilege));
			printf("user_name=%s,hasPrivilege=%d\n", user_name, hasPrivilege);


			if (!hasPrivilege)
			{
				char* item_id = NULL;
				POM_AM__set_application_bypass(true);
				ITKCALL(AOM_ask_value_string(revisions, "item_id", &item_id));

				strcat(resultString, item_id);
				strcat(resultString, "没有权限！\n");
				POM_AM__set_application_bypass(false);
				DOFREE(item_id);
				ifail = 1;
				continue;
			}
			//AOM_ask_value_tag(children_line[j], "bl_line_object", &revisions);

			tag_t item = NULLTAG;

			ITEM_ask_item_of_rev(revisions, &item);

			ITEM_ask_latest_rev(item, &revisions);

			/*char* revisionId = NULL;
			AOM_ask_value_string(revisions, "item_revision_id", &revisionId);
			if (strcmp(revisionId, "A") != 0)
			{
				DOFREE(revisionId);
				continue;
			}*/
			char* releaseString = NULL;
			//判断子件是否发布
			AOM_ask_value_string(children_line[j], "bl_rev_release_status_list", &releaseString);


			char* itemString = NULL;

			AOM_ask_value_string(children_line[j], "bl_rev_object_string", &itemString);

			printf("发布状态%s====================\n", releaseString);


			if (releaseString == NULL || strcmp(releaseString, "") == 0)
			{
				strcat(resultString, itemString);
				strcat(resultString, "\n");
				ifail = 1;
			}
			else
			{
				bool isHave = false;
				for (auto referencedValue : referenceValues) {

					if (strstr(releaseString, referencedValue) != NULL)
					{
						isHave = true;
						break;
					}
				}
				if (!isHave)
				{
					strcat(resultString, itemString);
					strcat(resultString, "发布状态不为");
					strcat(resultString, releaseStatus);
					strcat(resultString, "\n");
					ifail = 1;
				}
			}
			/*if (!IsRelease(children_line[j], resultString, referenceValues, releaseStatus))
			{
				ifail = 1;
			}*/
			DOFREE(releaseString);
			DOFREE(itemString);
			DOFREE(item_id);
			DOFREE(item_rev);
		}

		BOM_close_window(window);
		DOFREE(itemType);
		DOFREE(children_line);
	}
	DOFREE(attachments);
	DOFREE(user_name);
	if (ifail == 1)
	{
		strcat(resultString, "未发布！");
		EMH_store_error_s1(EMH_severity_user_error, EMH_USER_error_base, resultString);
	}

	auto stopTime = std::chrono::high_resolution_clock::now();
	auto duration = std::chrono::duration_cast<std::chrono::microseconds>(stopTime - startTime);
	//std::cout << "XY_ChildIsRelease用时:" << duration.count() / 1000 << std::endl;
	string usetime = "XY_ChildIsRelease用时:";
	usetime.append(std::to_string(duration.count() / 1000));
	WriteLog(true, usetime.c_str());
	printf("=========================判断子件是否全部发布 End====================\n");
	return ifail;
}

boolean IsRelease(tag_t topLine, char resultString[], vector<char*> referenceValues, char releaseStatus[1024])
{
	bool reault = true;
	int  count;
	tag_t* children_line = NULLTAG;

	BOM_line_ask_all_child_lines(topLine, &count, &children_line);
	for (int i = 0; i < count; i++)
	{
		char* releaseString = NULL;
		//判断子件是否发布
		AOM_ask_value_string(children_line[i], "bl_rev_release_status_list", &releaseString);

		char* itemString = NULL;

		AOM_ask_value_string(children_line[i], "bl_rev_object_string", &itemString);
		printf("发布状态%s====================\n", releaseString);

		if (releaseString == NULL || strcmp(releaseString, "") == 0)
		{
			strcat(resultString, itemString);
			strcat(resultString, "\n");
			reault = false;
		}
		else
		{
			bool isHave = false;
			for (auto referencedValue : referenceValues) {

				if (strstr(releaseString, referencedValue) != NULL)
				{
					isHave = true;
					break;
				}
			}
			if (!isHave)
			{
				strcat(resultString, itemString);
				strcat(resultString, "发布状态不为");
				strcat(resultString, releaseStatus);
				strcat(resultString, "\n");
				reault = false;
			}
		}
		if (!IsRelease(children_line[i], resultString, referenceValues, releaseStatus))
		{
			reault = false;
		}

		DOFREE(releaseString);
		DOFREE(itemString);
	}
	DOFREE(children_line);
	//POM_AM__set_application_bypass(false);
	return reault;
}