#include "util.h"
#include <ae/dataset.h>
#include <sa/am.h>


static void add_int_to_int_array(int add_int, int *n_int_array, int **int_array) {
	int count = *n_int_array;
	count++;
	if (count == 1) {
		(*int_array) = (int *)MEM_alloc(sizeof(int));
	} else {
		(*int_array) = (int *)MEM_realloc((*int_array), count * sizeof(int));
	}
	(*int_array)[count - 1] = add_int;
	*n_int_array = count;
}

static void add_tag_to_tag_array(tag_t add_tag, int *n_tag_array, tag_t **tag_array) {
	int count = *n_tag_array;
	count++;
	if (count == 1) {
		(*tag_array) = (tag_t *)MEM_alloc(sizeof(tag_t));
	} else {
		(*tag_array) = (tag_t *)MEM_realloc((*tag_array), count * sizeof(tag_t));
	}
	(*tag_array)[count - 1] = add_tag;
	*n_tag_array = count;
}

static void revise_item_revisions(int num_target_objs, tag_t *target_object_tags, vector<tag_t> *tags) {
	int *all_attached_object_count = NULL;
	tag_t *all_deepcopydata_tags;

	int n_ints_in_list = 0;
	int n_tags_in_list = 0;
	int *ifails = NULL;
	char *id_string = NULL;
	char type_name[TCTYPE_name_size_c + 1] = "";
	tag_t object_tag = NULLTAG;
	tag_t type_tag = NULLTAG;
	tag_t *attached_objs_tags = NULL;
	tag_t *target_copy_tags = NULL;
	tag_t *revise_input_tags = NULL;

	revise_input_tags = (tag_t *)MEM_alloc(num_target_objs * sizeof(tag_t));

	for (int ii = 0; ii < num_target_objs; ii++) {
		tag_t type_tag = NULLTAG;
		//询问对象的类型。
		TCTYPE_ask_object_type(target_object_tags[ii], &type_tag);

		tag_t revise_input_tag = NULLTAG;
		//为输入业务对象构造一个SaveAsInput对象。
		//使用这个SaveAsInput对象来保存用于创建对象的输入数据。
		TCTYPE_construct_operationinput(type_tag, TCTYPE_OPERATIONINPUT_REVISE, &revise_input_tag);
		revise_input_tags[ii] = revise_input_tag;

		printf("\nTarget Objects::\n");
		int attached_object_count = 0;
		tag_t *deepcopydata_tags = NULL;
		//检索输入对象(正在进行的顶级对象)的DeepCopyData标记opvar指定的操作类型，如SaveAs或modify。
		TCTYPE_ask_deepcopydata(target_object_tags[ii],
			TCTYPE_OPERATIONINPUT_REVISE, &attached_object_count, &deepcopydata_tags);
		tag_t last_object = NULLTAG;
		for (int jj = 0; jj < attached_object_count; jj++) {
			//询问单值属性的值。
			AOM_ask_value_tag(deepcopydata_tags[jj], "targetObject",&object_tag);
			if (object_tag != last_object) {
				//返回指定工作空间对象的对象ID。字符串是出现在工作区显示的对象列中的对象ID。
				WSOM_ask_object_id_string(object_tag, &id_string);
				//询问对象的类型。
				TCTYPE_ask_object_type(object_tag, &type_tag);
				//询问类型的名称。
				TCTYPE_ask_name(type_tag, type_name);
				printf("%s (%s)\n", id_string, type_name);
			}
			last_object = object_tag;
			//询问单值属性的值。
			AOM_ask_value_tag(deepcopydata_tags[jj], "attachedObject", &object_tag);
			if (object_tag != NULLTAG) {
				//返回指定工作空间对象的对象ID。字符串是出现在工作区显示的对象列中的对象ID。
				WSOM_ask_object_id_string(object_tag, &id_string);
				//询问对象的类型。
				TCTYPE_ask_object_type(object_tag, &type_tag);
				//询问类型的名称。
				TCTYPE_ask_name(type_tag, type_name);
				printf("attachedObject: %s (%s)\n", id_string, type_name);
			}
		}

		if (attached_object_count > 0) {
			add_int_to_int_array(attached_object_count, &n_ints_in_list,&all_attached_object_count);
			for (int jj = 0; jj < attached_object_count; jj++) {
				add_tag_to_tag_array(deepcopydata_tags[jj], &n_tags_in_list,&all_deepcopydata_tags);
			}
		}
		if (deepcopydata_tags) MEM_free(deepcopydata_tags);
	}
	//控件中的修改数据对指定的输入对象进行修改,属性和深度复制附加的对象,DeepCopyData提供。
	TCTYPE_revise_objects(num_target_objs, target_object_tags,
		revise_input_tags, all_attached_object_count, all_deepcopydata_tags,
		&target_copy_tags, &ifails);

	printf("\nNew Revisions:\n");
	for (int ii = 0; ii < num_target_objs; ii++) {
		//返回指定工作空间对象的对象ID。字符串是出现在工作区显示的对象列中的对象ID。
		WSOM_ask_object_id_string(target_copy_tags[ii],&id_string);
		//询问对象的类型。
		TCTYPE_ask_object_type(target_copy_tags[ii], &type_tag);
		//询问类型的名称。
		TCTYPE_ask_name(type_tag, type_name);

		if (ifails[ii] == ITK_ok) {
			printf("%s (%s)\n", id_string, type_name);
			(*tags).push_back(target_copy_tags[ii]);
		} else {
			char *error_message_string;
			EMH_get_error_string(NULLTAG, ifails[ii], &error_message_string);
			printf("\t%d %s\n", ifails[ii], error_message_string);
			if (error_message_string) MEM_free(error_message_string);
		}
	}

	if (revise_input_tags) MEM_free(revise_input_tags);
	if (all_attached_object_count) MEM_free(all_attached_object_count);
	if (all_deepcopydata_tags) MEM_free(all_deepcopydata_tags);
	if (attached_objs_tags) MEM_free(attached_objs_tags);
	if (target_copy_tags) MEM_free(target_copy_tags);
	if (ifails) MEM_free(ifails);
	if (id_string) MEM_free(id_string);
}

static int grant_access(tag_t dataset_tag, tag_t user)
{
	int     ifail = ITK_ok;
	tag_t   write_prev = NULLTAG;

	ifail = AOM_refresh(dataset_tag, POM_modify_lock);
	if (ifail != ITK_ok)
	{
		return ifail;
	}

	ifail = AM_find_privilege("WRITE", &write_prev);
	if (ifail != ITK_ok)
	{
		AOM_unlock(dataset_tag);
		return ifail;
	}
	
	ifail = AM_grant_privilege(dataset_tag, user, write_prev);//赋予写权限
	if (ifail != ITK_ok)
	{
		AOM_unlock(dataset_tag);
		return ifail;
	}

	ifail = AM_save_acl(dataset_tag);
	if (ifail != ITK_ok)
	{
		AOM_unlock(dataset_tag);
		return ifail;
	}

	ifail = AE_save_myself(dataset_tag);
	if (ifail != ITK_ok)
	{
		AOM_unlock(dataset_tag);
		return ifail;
	}
	return ifail;
}

int jd_auto_revise(EPM_action_message_t msg) {
	int att_cnt;
	tag_t root_task, *attachments;
	//获得根节点
	EPM_ask_root_task(msg.task, &root_task);
	//获得根任务下的组件
	EPM_ask_attachments(root_task, EPM_target_attachment, &att_cnt, &attachments);
	vector<tag_t> revs;
	vector<tag_t> tags;
	vector<tag_t> items;
	POM_AM__set_application_bypass(true);
	//遍历任务组件
	for (int i = 0;i < att_cnt;i++) {
		if (isTypeOf(attachments[i], "ItemRevision")) {
			revs.push_back(attachments[i]);
			//////////////////////////////////////////////////////////////////////////////////////
			int object_att;
			tag_t* object;
			//得到零组件
			AOM_ask_value_tags(attachments[i], "items_tag", &object_att, &object);

			tag_t owning_user, group;
			//询问单值属性的值。获取对象所有者
			AOM_ask_value_tag(msg.task, "owning_user", &owning_user);
			//给写权限
			grant_access(object[0], owning_user);

			//返回用户的默认登录组属性。
			//SA_ask_user_login_group(owning_user, &group);

			//AOM_lock(object[0]);
			//int res = ITK_ok;
			//char* uid;
			////设置对象的用户和组所有权。
			//ITKCALL(AOM_set_ownership(object[0], owning_user, group));
			////将应用程序对象保存到数据库中。在调用save之前，必须首先加载或刷新对象以进行修改。
			//ITKCALL(res = AOM_save(object[0]));
			//if (res != ITK_ok) {
			//	//注意返回的“UID”对于一个BOM标签不是持久化到另一个会话，并且对于道具标签是无效的
			//	ITK__convert_tag_to_uid(object[0], &uid);
			//	cout << uid << endl;
			//	//释放指定的内存块。
			//	if (uid)  MEM_free(uid);
			//}
			//AOM_unlock(object[0]);
			//////////////////////////////////////////////////////////////////////////////////////
		}
	}
	revise_item_revisions(revs.size(), &revs[0], &tags);
	if (tags.size() > 0) {
		tag_t owning_user, group;
		char *name, **prefs;
		int prefs_cnt = 0, tags_cnt = tags.size();
		//询问单值属性的值。获取对象所有者
		AOM_ask_value_tag(msg.task, "owning_user", &owning_user);
		//询问单值属性的值。获取用户name
		AOM_ask_value_string(owning_user, "object_string", &name);
		cout << "owning_user:" << name << endl;
		//返回用户的默认登录组属性。
		SA_ask_user_login_group(owning_user, &group);
		char *group_name;
		//询问单值属性的值。
		AOM_ask_value_string(group, "object_string", &group_name);
		cout << "group name:" << group_name << endl;
		//询问数据类型为“String”的首选项的所有值。
		PREF_ask_char_values("jd2_auto_revise_relations", &prefs_cnt, &prefs);
		for (int i = 0;i < prefs_cnt;i++) {
			cout << "relation:" << prefs[i] << endl;
			for (int ii = 0;ii < tags_cnt;ii++) {
				tag_t *temp;
				int num = 0;
				//询问属性的一个或多个值。属性可以是单值的，也可以是多值的(例如，数组或列表)。
				AOM_ask_value_tags(tags[ii], prefs[i], &num, &temp);
				for (int iii = 0;iii < num;iii++) {
					char *str;
					//询问单值属性的值。
					AOM_ask_value_string(temp[iii], "object_string", &str);
					cout << "add name:" << str << endl;
					tags.push_back(temp[iii]);
				}
			}
		}

		for (int i = 0;i < tags.size();i++) {
			AOM_lock(tags[i]);
			int res = ITK_ok;
			char *uid;
			//设置对象的用户和组所有权。
			ITKCALL(AOM_set_ownership(tags[i], owning_user, group));
			//将应用程序对象保存到数据库中。在调用save之前，必须首先加载或刷新对象以进行修改。
			ITKCALL(res = AOM_save(tags[i]));
			if (res != ITK_ok) {
				//注意返回的“UID”对于一个BOM标签不是持久化到另一个会话，并且对于道具标签是无效的
				ITK__convert_tag_to_uid(tags[i], &uid);
				cout << uid << endl;
				//释放指定的内存块。
				if (uid)  MEM_free(uid);
			}
			AOM_unlock(tags[i]);
			//if (isTypeOf(tags[i], "Dataset")) {
				//int ref_cnt;
				//tag_t *refs;
				//AOM_ask_value_tags(tags[i], "ref_list", &ref_cnt, &refs);
				//cout << "dataset ref cnt:" << ref_cnt << endl;
				//for (int iiii = 0;iiii < ref_cnt;iiii++) {
				//	//tags.push_back(refs[iiii]);
				//	AOM_lock(refs[iiii]);
				//	ITKCALL(POM_set_owning_group(refs[iiii], group));
				//	ITKCALL(POM_set_owning_user(refs[iiii], owning_user));
				//	AOM_save(refs[iiii]);
				//	AOM_unlock(refs[iiii]);
				//}
				//tag_t latest_dataset;
				//AE_ask_dataset_latest_rev(tags[i], &latest_dataset);
				//AOM_lock(latest_dataset);
			//	ITKCALL(POM_set_owning_group(tags[i], group));

			//	ITKCALL(POM_set_owning_user(tags[i], owning_user));
			//	ITKCALL(POM_set_modification_user(tags[i], owning_user));
			//	ITKCALL(AE_save_myself(tags[i]));

			//	

			//	AOM_save(tags[i]);
			//	AOM_unlock(tags[i]);
			//} else {
			//	ITKCALL(POM_set_owning_group(tags[i], group));
			//	ITKCALL(POM_set_owning_user(tags[i], owning_user));
			//	AOM_save(tags[i]);
			//	AOM_unlock(tags[i]);
			//}
		}
		cout << "success" << endl;
	} else {
		cout << "revs cnt:0" << endl;
	}
	POM_AM__set_application_bypass(false);
	return 0;
}