/*
 * oma-ds-agent
 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the License);
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 *   @SE_Sync.c
 *   @version									0.1
 *   @brief										This file is the source file of implementation of functions which process sync request, auto configure etc..
 */

#include <sys/time.h>

#include <sync_agent.h>
#include <plugin/plugin_slp_device.h>

#include "service-engine/se_sync.h"
#include "service-engine/se_storage.h"
#include "service-engine/se_common.h"
#include "service-engine/se_notification.h"
#include "service-adapter/sa_common_interface.h"
#include "common/common_util.h"
#include "common/common_define_internal.h"

#ifndef OMADS_AGENT_LOG
#undef LOG_TAG
#define LOG_TAG "OMA_DS_SE"
#endif

static int __convert_alert_to_sync_type_value(alert_type_e sync_type);
static int __convert_src_uri_value(char *src_uri);
static se_error_type_e _session_process(int account_id, alert_type_e server_sync_type, sync_progress_e process, sync_error_e error);
static se_error_type_e __process_update(int account_id, alert_type_e server_sync_type, sync_progress_status_e progress_status, operation_type_e operation_type, int content_type, bool is_from_server, bool need_to_save, sync_result_s * sync_result);
static se_error_type_e _write_sync_data(int account_id, alert_type_e alert_type, sync_session_result_e sync_session_result, int last_session_time, int only_from_client);
static se_error_type_e ___write_sync_resource_info(int account_id, int content_type, int last_session_time, int only_from_client, sync_result_s * client_sync_result, sync_result_s * server_sync_result);

static se_error_type_e __init_datastore_info_array(int account_id);
static se_error_type_e ___set_datastore_info_array(int account_id, char *config_key, service_type_e content_type);
static se_error_type_e ___generate_datastore_info(int account_id, service_type_e content_type, datastore_s ** datastore);
static se_error_type_e __init_datastore_info(int account_id, service_type_e content_type, datastore_s ** datastore);
static se_error_type_e ___set_datastore_config(int account_id, int content_type, datastore_s ** datastore);
static se_error_type_e __get_sync_type(int account_id, alert_type_e * sync_type);

static se_error_type_e __on_synchronising_account(int account_id);
static se_error_type_e _off_synchronising_account(int account_id);

static se_error_type_e __on_resume_flag(int account_id);
static se_error_type_e _off_resume_flag(int account_id);

static se_error_type_e _assemble_changed_datastores(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj);
static se_error_type_e _prepare_pre_sync(int account_id, char *sync_mode, san_package_s * san_package, alert_type_e * sync_type);
static se_error_type_e __set_config_based_on_sync_mode(int account_id, char *sync_mode, san_package_s * san_package);
static se_error_type_e _execute_pre_sync(int account_id, int session_time, pre_sync_return_obj_s * pre_sync_return_obj, alert_type_e * server_sync_type);
static se_error_type_e __execute_pre_sync_set_server_id(int account_id, char *dev_id);
static se_error_type_e __execute_pre_sync_datastore(int account_id, int session_time, GList * datastore_info, alert_type_e * server_sync_type);
static se_error_type_e _execute_sync(int account_id, alert_type_e client_sync_type, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj);
static se_error_type_e __execute_sync_arrange_changelog(int account_id, alert_type_e sync_type, GList * status);
static se_error_type_e __execute_sync_status(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj);
static se_error_type_e __execute_sync_change(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj);
static se_error_type_e _update_sync_result(int account_id);

static command_result_e ___convert_return_status(sync_agent_da_return_e da_err);
static char *__convert_cttype_str(int itemTypeId);
static int ___convert_sync_type_value(char *sync_type_str);
static char *__convert_sync_type_str(alert_type_e sync_type);
static char *___convert_sync_progress_status_str(sync_progress_status_e progress_status);
static char *___convert_operation_type_str(operation_type_e operation_type);
static char *_convert_sync_progress_str(sync_progress_e process);
static char *_convert_sync_error_str(sync_error_e error);
static se_error_type_e _check_low_battery();
static se_error_type_e _open_services();
static se_error_type_e _close_services();

static inline long myclock()
{
	struct timeval tv;
	gettimeofday(&tv, 0);
	return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
}

static int __convert_alert_to_sync_type_value(alert_type_e sync_type)
{
	_INNER_FUNC_ENTER;

	int sync_type_value = 0;
	_DEBUG_INFO("sync_type: [%d]", sync_type);

	switch (sync_type) {
	case ALERT_TWO_WAY:
		sync_type_value = SYNC_TYPE_UPDATE_BOTH;
		break;
	case ALERT_SLOW_SYNC:
		sync_type_value = SYNC_TYPE_FULL_SYNC;
		break;
	case ALERT_ONE_WAY_FROM_CLIENT:
		sync_type_value = SYNC_TYPE_UPDATE_TO_SERVER;
		break;
	case ALERT_REFRESH_FROM_CLIENT:
		sync_type_value = SYNC_TYPE_REFRESH_FROM_PHONE;
		break;
	case ALERT_ONE_WAY_FROM_SERVER:
		sync_type_value = SYNC_TYPE_UPDATE_TO_PHONE;
		break;
	case ALERT_REFRESH_FROM_SERVER:
		sync_type_value = SYNC_TYPE_REFRESH_FROM_SERVER;
		break;
	default:
		_DEBUG_ERROR("sync_type is invalid!!");
		break;
	}

	_INNER_FUNC_EXIT;
	return sync_type_value;
}

static int __convert_src_uri_value(char *src_uri)
{
	_INNER_FUNC_ENTER;

	int src_uri_value = 0;
	_DEBUG_INFO("src_uri: [%s]", src_uri);

	if (strcmp(src_uri,DEFINE_SOURCE_CONTACT_URI) == 0) {
		src_uri_value = SRC_URI_CONTACT;
	} else if (strcmp(src_uri,DEFINE_SOURCE_CALENDAR_URI)) {
		src_uri_value = SRC_URI_CALENDAR;
	} else if (strcmp(src_uri,DEFINE_SOURCE_MEMO_URI)) {
		src_uri_value = SRC_URI_MEMO;
	} else if (strcmp(src_uri,DEFINE_SOURCE_CALLLOG_URI)) {
		src_uri_value = SRC_URI_CALLLOG;
	} else {
		_DEBUG_ERROR("src_uri is invalid!!");
	}

	_INNER_FUNC_EXIT;
	return src_uri_value;
}

static se_error_type_e _session_process(int account_id, alert_type_e server_sync_type, sync_progress_e process, sync_error_e error)
{
	_INNER_FUNC_ENTER;

	char *profileDirName = NULL;
	se_error_type_e err = SE_INTERNAL_OK;
	bool result;
	int sync_type_value = 0;

	result = get_config(account_id, DEFINE_CONFIG_KEY_PROFILE_DIR_NAME, &profileDirName);
	if (result == false) {
		_DEBUG_ERROR("failed in get_Config");
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

      sync_type_value = __convert_alert_to_sync_type_value(server_sync_type);
	_DEBUG_INFO("sync_type_value: [%d]", sync_type_value);

	if (profileDirName != NULL) {
		err = session_process(profileDirName, sync_type_value, process, error);
		if (err != SE_INTERNAL_OK) {
			_DEBUG_ERROR("failed to send noti");
			goto error;
		}
	}

 error:
	if (profileDirName != NULL) {
		free(profileDirName);
		profileDirName = NULL;
	}

	_INNER_FUNC_EXIT;

	return err;
}

static se_error_type_e __process_update(int account_id, alert_type_e server_sync_type, sync_progress_status_e progress_status, operation_type_e operation_type, int content_type, bool is_from_server, bool need_to_save, sync_result_s * sync_result)
{
	_INNER_FUNC_ENTER;

	_DEBUG_VERBOSE("account_id =%d, progress_status = %d, operation_type = %d, content_type = %d, isFromServer = %d, needToSave = %d ", account_id, progress_status, operation_type, content_type, is_from_server, need_to_save);
	_DEBUG_VERBOSE("numberOfChange = %d, received_count = %d,  syncCount = %d", sync_result->number_of_change, sync_result->received_count, sync_result->add_count + sync_result->replace_count + sync_result->delete_count);

	se_error_type_e err = SE_INTERNAL_OK;
	char *profileDirName = NULL;
	char *uri = NULL;
	char *sync_type = NULL;
	char *operation = NULL;
	char *progress = NULL;
	int sync_type_value = 0;
	int uri_value = 0;

	bool result;
	result = get_config(account_id, DEFINE_CONFIG_KEY_PROFILE_DIR_NAME, &profileDirName);
	if (result == false) {
		_DEBUG_ERROR("failed in get_Config");
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

	/* do not need to send update noti to ui */
	if (profileDirName == NULL) {
		_DEBUG_VERBOSE("profileDirName is NULL");
		goto error;
	}

	if (need_to_save == true) {
		err = write_sync_statistics(account_id, content_type, is_from_server, sync_result);
		if (err != SE_INTERNAL_OK) {
			_DEBUG_ERROR("failed in writeSyncStatistics");
			goto error;
		}
	}

	sync_type = __convert_sync_type_str(server_sync_type);
	sync_type_value = __convert_alert_to_sync_type_value(server_sync_type);
	_DEBUG_INFO("sync_type_value: [%d]", sync_type_value);

	progress = ___convert_sync_progress_status_str(progress_status);

	operation = ___convert_operation_type_str(operation_type);

	if (sync_type == NULL || progress == NULL || operation == NULL) {
		err = SE_INTERNAL_NOT_DEFINED;
		goto error;
	}

	if (datastoreinfo_per_content_type[content_type] != NULL) {
		if (datastoreinfo_per_content_type[content_type]->source != NULL)
			uri = strdup(datastoreinfo_per_content_type[content_type]->source);
	}
	if (uri != NULL) {
		uri_value = __convert_src_uri_value(uri);
		_DEBUG_INFO("uri_value: [%d]", uri_value);
	} else {
		_DEBUG_ERROR("uri is NULL!!");
		goto error;
	}

	err = send_noti_process_update(profileDirName, sync_type_value, uri_value, progress, operation, is_from_server, 0, 0, sync_result->number_of_change, sync_result->add_count + sync_result->replace_count + sync_result->delete_count);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in send_noti_process_update");
		goto error;
	}

 error:

	if (profileDirName != NULL)
		free(profileDirName);

	if (uri != NULL)
		free(uri);

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e _write_sync_data(int account_id, alert_type_e alert_type, sync_session_result_e sync_session_result, int last_session_time, int only_from_client)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	err = write_profile_data(account_id, alert_type, sync_session_result, last_session_time, only_from_client);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in writeProfileData");
		goto error;
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e ___write_sync_resource_info(int account_id, int content_type, int last_session_time, int only_from_client, sync_result_s * client_sync_result, sync_result_s * server_sync_result)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	err = write_sync_resource_info(account_id, content_type, last_session_time, only_from_client, client_sync_result, server_sync_result);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in write_sync_resource_info");
		goto error;
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e __init_datastore_info_array(int account_id)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	err = ___set_datastore_info_array(account_id, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CONTACTS, TYPE_CONTACT);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in set_datastoreinfo_array");
		goto error;
	}

	err = ___set_datastore_info_array(account_id, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALENDAR, TYPE_CALENDAR);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in set_datastoreinfo_array");
		goto error;
	}

	err = ___set_datastore_info_array(account_id, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_MEMO, TYPE_MEMO);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in set_datastoreinfo_array");
		goto error;
	}

	err = ___set_datastore_info_array(account_id, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALLLOG, TYPE_CALLLOG);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in set_datastoreinfo_array");
		goto error;
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e ___set_datastore_info_array(int account_id, char *config_key, service_type_e content_type)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	datastore_s *datastore_info = NULL;
	bool result;
	char *value = NULL;

	result = get_config(account_id, config_key, &value);
	if (result == true) {
		if (strcmp(value, "1") == 0) {
			err = ___generate_datastore_info(account_id, content_type, &datastore_info);
			if (err != SE_INTERNAL_OK) {
				_DEBUG_ERROR("failed to create or init datastore_info");
				datastoreinfo_per_content_type[content_type] = NULL;
				goto error;
			}
			datastoreinfo_per_content_type[content_type] = datastore_info;
		}

	} else
		datastoreinfo_per_content_type[content_type] = NULL;

 error:

	if (value != NULL)
		free(value);

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e ___generate_datastore_info(int account_id, service_type_e content_type, datastore_s ** datastore)
{
	_INNER_FUNC_ENTER;
	_DEBUG_VERBOSE("content_type=[%d]\n", content_type);

	se_error_type_e err = SE_INTERNAL_OK;
	char *clientLastAnchor = NULL;
	char *clientNextAnchor = NULL;
	char *serverLastAnchor = NULL;

	sync_agent_da_return_e da_err = SYNC_AGENT_DA_ERRORS;

	sync_result_s *pSyncResult = NULL;
	datastore_s *temp_datastore = NULL;
	err = ___set_datastore_config(account_id, content_type, &temp_datastore);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in set_datastore_config");
		goto error;
	}

	GList *anchor_list = NULL;
	sync_agent_da_get_last_anchor_list_query_s query;
	query.option = SYNC_AGENT_DA_GET_LAST_ANCHOR_LIST_OPTION_ITEM_TYPE_ID;
	query.account_id = account_id;
	query.item_type_id = temp_datastore->datastore_id;

	da_err = sync_agent_get_last_anchor_list(&query, &anchor_list);
	if (da_err != SYNC_AGENT_DA_SUCCESS) {
		_DEBUG_ERROR("failed in sync_agent_get_last_anchor_list !!");
		goto error;
	}

	if (g_list_length(anchor_list) > 0) {
		GList *last_anchor_info = g_list_nth(anchor_list, g_list_length(anchor_list) - 1);
		clientLastAnchor = ((sync_agent_da_last_anchor_s *) (last_anchor_info->data))->last_anchor_client;
		serverLastAnchor = ((sync_agent_da_last_anchor_s *) (last_anchor_info->data))->last_anchor_server;
	} else {
		sync_agent_da_last_anchor_s lastAnchor_daci;

		lastAnchor_daci.account_id = account_id;
		lastAnchor_daci.data_store_id = temp_datastore->datastore_id;
		lastAnchor_daci.last_anchor_server = NULL;
		lastAnchor_daci.last_anchor_client = NULL;
		lastAnchor_daci.access_name = "Engine";

		da_err = sync_agent_add_last_anchor(&lastAnchor_daci);
		if (da_err != SYNC_AGENT_DA_SUCCESS) {
			_DEBUG_ERROR("da_add_last_anchor_internal is failed %d", da_err);
			err = SE_INTERNAL_DA_ERROR;
			goto error;
		}
	}

	clientNextAnchor = g_strdup_printf("%ld", time(NULL));

	_DEBUG_VERBOSE("clientLastAnchor = %s\n", clientLastAnchor);
	_DEBUG_VERBOSE("serverLastAnchor = %s\n", serverLastAnchor);
	_DEBUG_VERBOSE("clientNextAnchor = %s\n", clientNextAnchor);

	/*slow sync if managed anchor info not exist.. (first sync) */
	if (clientLastAnchor == NULL)
		set_datastore_client_anchor(temp_datastore, clientNextAnchor, clientNextAnchor);
	else
		set_datastore_client_anchor(temp_datastore, clientLastAnchor, clientNextAnchor);

	set_datastore_server_anchor(temp_datastore, serverLastAnchor, NULL);

	pSyncResult = create_sync_result();
	if (pSyncResult == NULL) {
		_DEBUG_ERROR("create_syncResult is failed");
		err = SE_INTERNAL_NO_MEMORY;
		goto error;
	}
	temp_datastore->client_sync_result = pSyncResult;

	pSyncResult = create_sync_result();
	if (pSyncResult == NULL) {
		_DEBUG_ERROR("create_syncResult is failed");
		err = SE_INTERNAL_NO_MEMORY;
		goto error;
	}
	temp_datastore->server_sync_result = pSyncResult;

	*datastore = temp_datastore;
	temp_datastore = NULL;

 error:

	if (clientNextAnchor != NULL)
		free(clientNextAnchor);

	if (temp_datastore != NULL)
		free_datastore(temp_datastore);

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e __init_datastore_info(int account_id, service_type_e content_type, datastore_s ** datastore)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	char *sourceDatastore = NULL;
	char key[128];
	datastore_s *temp_datastore = NULL;
	sync_result_s *pSyncResult = NULL;

	bool result;
	switch (content_type) {
	case TYPE_CONTACT:
		snprintf(key, sizeof(key), "%s_%s", DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CONTACTS, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_SOURCE);
		break;
	case TYPE_CALENDAR:
		snprintf(key, sizeof(key), "%s_%s", DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALENDAR, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_SOURCE);
		break;
	case TYPE_MEMO:
		snprintf(key, sizeof(key), "%s_%s", DEFINE_CONFIG_KEY_PROFILE_CATEGORY_MEMO, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_SOURCE);
		break;
	case TYPE_CALLLOG:
		snprintf(key, sizeof(key), "%s_%s", DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALLLOG, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_SOURCE);
		break;
	default:
		_DEBUG_VERBOSE("unknown content type = %d", content_type);
		goto error;
	}

	_DEBUG_ERROR("content_type = %d", content_type);
	_DEBUG_ERROR("key = %s", key);
	result = get_config(account_id, key, &sourceDatastore);
	if (result == false) {
		_DEBUG_ERROR("failed in get_Config");
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

	temp_datastore = create_datastore(NULL, sourceDatastore);
	if (temp_datastore == NULL) {
		_DEBUG_ERROR("failed to create_Datastore");
		err = SE_INTERNAL_NO_MEMORY;
		goto error;
	}

	pSyncResult = create_sync_result();
	if (pSyncResult == NULL) {
		_DEBUG_ERROR("create_syncResult is failed");
		err = SE_INTERNAL_NO_MEMORY;
		goto error;
	}
	temp_datastore->client_sync_result = pSyncResult;

	pSyncResult = create_sync_result();
	if (pSyncResult == NULL) {
		_DEBUG_ERROR("create_syncResult is failed");
		err = SE_INTERNAL_NO_MEMORY;
		goto error;
	}
	temp_datastore->server_sync_result = pSyncResult;

	*datastore = temp_datastore;
	temp_datastore = NULL;

 error:
	if (sourceDatastore != NULL)
		free(sourceDatastore);

	if (temp_datastore != NULL)
		free_datastore(temp_datastore);

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e ___set_datastore_config(int account_id, int content_type, datastore_s ** datastore)
{
	_INNER_FUNC_ENTER;

	datastore_s *temp_datastore = NULL;
	se_error_type_e err = SE_INTERNAL_OK;
	sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;

	char *contentType = NULL;

	char sourceDatastore_key[128];
	char targetDatastore_key[128];
	char id_key[128];
	char pw_key[128];

	char *sourceDatastore = NULL;
	char *targetDatastore = NULL;
	char *sync_type = NULL;
	char *id = NULL;
	char *pw = NULL;

	alert_type_e alert_type = ALERT_UNKNOWN;

	GList *config_list = NULL;
	GList *iter = NULL;
	sync_agent_da_config_s *config_data = NULL;

	int folder_type_id = 0;
	switch (content_type) {
	case TYPE_CONTACT:
		{
			folder_type_id = 0;
			contentType = DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CONTACTS;
		}
		break;
	case TYPE_CALENDAR:
		{
			folder_type_id = 0;
			contentType = DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALENDAR;
		}
		break;
	case TYPE_MEMO:
		{
			folder_type_id = 0;
			contentType = DEFINE_CONFIG_KEY_PROFILE_CATEGORY_MEMO;
		}
		break;
	case TYPE_CALLLOG:
		{
			folder_type_id = 0;
			contentType = DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALLLOG;
		}
		break;
	default:
		_DEBUG_VERBOSE("unknown content type = %d", content_type);
		err = SE_INTERNAL_ERROR;
		goto error;
	}

	snprintf(sourceDatastore_key, sizeof(sourceDatastore_key), "%s_%s", contentType, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_SOURCE);
	snprintf(targetDatastore_key, sizeof(targetDatastore_key), "%s_%s", contentType, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_TARGET);
	snprintf(id_key, sizeof(id_key), "%s_%s", contentType, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_ID);
	snprintf(pw_key, sizeof(id_key), "%s_%s", contentType, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_PASSWORD);

	da_err = sync_agent_get_config_list(account_id, &config_list);
	if (da_err != SYNC_AGENT_DA_SUCCESS) {
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

	for (iter = config_list; iter != NULL; iter = g_list_next(iter)) {
		config_data = (sync_agent_da_config_s *) iter->data;

		if (config_data != NULL) {
			if (config_data->key != NULL) {
				if (strcmp(config_data->key, sourceDatastore_key) == 0) {
					if (config_data->value != NULL)
						sourceDatastore = strdup(config_data->value);
				}

				if (strcmp(config_data->key, targetDatastore_key) == 0) {
					if (config_data->value != NULL)
						targetDatastore = strdup(config_data->value);
				}

				if (strcmp(config_data->key, DEFINE_CONFIG_KEY_PROFILE_CLIENT_SYNC_TYPE) == 0) {
					if (config_data->value != NULL)
						sync_type = strdup(config_data->value);
				}

				if (strcmp(config_data->key, id_key) == 0) {
					if (config_data->value != NULL)
						id = strdup(config_data->value);
				}

				if (strcmp(config_data->key, pw_key) == 0) {
					if (config_data->value != NULL)
						pw = strdup(config_data->value);
				}
			}
		}
	}

	if (sync_type != NULL) {
		alert_type = ___convert_sync_type_value(sync_type);
	} else {
		_DEBUG_ERROR("sync_type is NULL !");
		err = SE_INTERNAL_ERROR;
		goto error;
	}

	_DEBUG_VERBOSE("get_Config result  sourceDatastore= %s ", sourceDatastore);
	_DEBUG_VERBOSE("get_Config result  targetDatastore= %s ", targetDatastore);
	_DEBUG_VERBOSE("get_Config result  alert_type= %s ", sync_type);
	_DEBUG_VERBOSE("get_Config result  id= %s ", id);
	_DEBUG_VERBOSE("get_Config result  pw= %s ", pw);

	temp_datastore = create_datastore(targetDatastore, sourceDatastore);
	if (temp_datastore == NULL) {
		_DEBUG_ERROR("temp_datastore is NULL");
		err = SE_INTERNAL_ERROR;
		goto error;
	}

	set_datastore_content_type_info(temp_datastore, content_type, folder_type_id);
	set_datastore_account_info(temp_datastore, id, pw);
	set_datastore_client_sync_type(temp_datastore, alert_type);

	*datastore = temp_datastore;
	temp_datastore = NULL;

 error:

	if (sourceDatastore != NULL)
		free(sourceDatastore);

	if (targetDatastore != NULL)
		free(targetDatastore);

	if (sync_type != NULL)
		free(sync_type);

	if (id != NULL)
		free(id);

	if (pw != NULL)
		free(pw);

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e __get_sync_type(int account_id, alert_type_e * alert_type)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	char *sync_type = NULL;

	bool result = get_config(account_id, DEFINE_CONFIG_KEY_PROFILE_CLIENT_SYNC_TYPE, &sync_type);
	if (result == false) {
		_DEBUG_ERROR("failed in get_Config");
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

	*alert_type = ___convert_sync_type_value(sync_type);

 error:

	if (sync_type != NULL)
		free(sync_type);

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e __on_synchronising_account(int account_id)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	bool result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_SYNCHRONISING, "1", "string", "SE");
	if (result == false) {
		_DEBUG_ERROR("failed in set_Config");
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e _off_synchronising_account(int account_id)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	bool result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_SYNCHRONISING, "0", "string", "SE");
	if (result == false) {
		_DEBUG_ERROR("failed in set_Config");
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e __on_resume_flag(int account_id)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	bool result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_RESUME, "1", "string", "SE");
	if (result == false) {
		_DEBUG_ERROR("failed in set_Config");
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e _off_resume_flag(int account_id)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	bool result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_RESUME, "0", "string", "SE");
	if (result == false) {
		_DEBUG_ERROR("failed in set_Config");
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e _assemble_changed_datastores(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	changed_datastore_s *pChangedDatastore = NULL;
	sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;

	int content_type;
	for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
		if (datastoreinfo_per_content_type[content_type] != NULL) {
			if (!datastoreinfo_per_content_type[content_type]->client_sync_type)
				continue;

			if (datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_SLOW_SYNC
			    || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_CLIENT || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_CLIENT_BY_SERVER) {

				if (content_type == TYPE_CALLLOG) {
					_DEBUG_TRACE("sync_agent_refresh_item_tbl_from_service for call log");
					sync_agent_refresh_item_tbl_from_service(account_id, datastoreinfo_per_content_type[content_type]->datastore_id);
				}

				GList *item_list = NULL;
				sync_agent_da_get_item_list_query_s query;
				query.option = SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_ACCOUNT_ID;
				query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;

				da_err = sync_agent_get_item_list(account_id, &query, &item_list);
				if (da_err != SYNC_AGENT_DA_SUCCESS) {
					_DEBUG_ERROR("failed in sync_agent_get_item_list !!");
				}

				pChangedDatastore = create_changed_datastore(datastoreinfo_per_content_type[content_type]->source, datastoreinfo_per_content_type[content_type]->target, 1, g_list_length(item_list));

				if (pChangedDatastore == NULL) {
					sync_agent_free_item_list(item_list);
					_DEBUG_ERROR("failed in create_ChangedDatastore");
					err = SE_INTERNAL_NO_MEMORY;
					goto error;
				}

				if (g_list_length(item_list) > 0) {
					GList *iter = NULL;
					sync_agent_da_item_s *iter_data;
					for (iter = item_list; iter != NULL; iter = g_list_next(iter)) {
						iter_data = NULL;
						iter_data = (sync_agent_da_item_s *) (iter->data);
						if (iter_data != NULL) {
							char *cttype = __convert_cttype_str(iter_data->data_store_id);
							changed_item_s *pChanged = create_changed_item(CHANGE_ADD, iter_data->item_id);
							if (pChanged == NULL) {
								sync_agent_free_item_list(item_list);
								_DEBUG_ERROR("failed in create_ChangedDatastore");
								err = SE_INTERNAL_NO_MEMORY;
								goto error;
							}

							set_changed_item_content_type(pChanged, cttype);
							set_changed_item_index_of_datastore(pChanged, content_type);

							add_changed_datastore_changed_item(pChangedDatastore, pChanged);
						} else {
							_DEBUG_ERROR("iter_data is NULL !!");
							sync_agent_free_item_list(item_list);
							err = SE_INTERNAL_NO_MEMORY;
							goto error;
						}
					}

					sync_agent_free_item_list(item_list);
				}

				GList *item_id_list = NULL;

				sync_agent_da_get_item_id_list_query_s item_id_query = {0,};
				item_id_query.option = SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_OPERATION_ID_N_ITEM_TYPE_ID;
				item_id_query.account_id = account_id;
				item_id_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;
				item_id_query.operation_id = SYNC_AGENT_DA_CHANGE_OPERATION_DELETE;

				da_err = sync_agent_get_item_id_list(&item_id_query, &item_id_list);
				if (da_err != SYNC_AGENT_DA_SUCCESS) {
					_DEBUG_ERROR("failed in sync_agent_get_item_id_list !!");
					err = SE_INTERNAL_DA_ERROR;
					goto error;
				}

				GList *item_id_iter = NULL;
				char *item_id;

				if (g_list_length(item_id_list) > 0) {
					for (item_id_iter = item_id_list; item_id_iter != NULL; item_id_iter = g_list_next(item_id_iter)) {
						item_id = NULL;
						item_id = (char *)(item_id_iter->data);

						da_err = sync_agent_delete_item(item_id, 1);
						if (da_err != SYNC_AGENT_DA_SUCCESS) {
							_DEBUG_ERROR("failed in sync_agent_delete_item !!");
							sync_agent_free_item_id_list(item_id_list);
							err = SE_INTERNAL_DA_ERROR;
							goto error;
						}
					}
				}

				sync_agent_free_item_id_list(item_id_list);

				/*delete changelog data by account id and datastore id */
				sync_agent_da_delete_changelog_query_s delete_ch_query = {0,};
				delete_ch_query.option = SYNC_AGENT_DA_DELETE_CHANGELOG_OPTION_ITEM_TYPE_ID;
				delete_ch_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;

				da_err = sync_agent_delete_changelog(account_id, &delete_ch_query);
				if (da_err != SYNC_AGENT_DA_SUCCESS) {
					_DEBUG_ERROR("failed in sync_agent_delete_changelog !!");
					err = SE_INTERNAL_DA_ERROR;
					goto error;
				}
			} else if (datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_TWO_WAY
				   || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_TWO_WAY_BY_SERVER
				   || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_ONE_WAY_FROM_CLIENT || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_ONE_WAY_FROM_CLIENT_BY_SERVER) {
				_DEBUG_TRACE("server sync type is ALERT_TYPE [%d]", datastoreinfo_per_content_type[content_type]->server_sync_type);

				/*on resume flag into agent DB */
				err = __on_resume_flag(account_id);
				if (err != SE_INTERNAL_OK) {
					_DEBUG_ERROR("failed in __on_resume_flag");
					goto error;
				}

				if (content_type == TYPE_CALLLOG) {
					_DEBUG_TRACE("sync_agent_construct_item_tbl_from_service for call log");
					sync_agent_construct_item_tbl_from_service(account_id, content_type);
				}

				/*from changelog */
				GList *item_info_list = NULL;
				sync_agent_da_get_changelog_list_query_s get_ch_query;
				get_ch_query.option = SYNC_AGENT_DA_GET_CHANGELOG_LIST_OPTION_ITEM_TYPE_ID;
				get_ch_query.account_id = account_id;
				get_ch_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;

				da_err = sync_agent_get_changelog_list(&get_ch_query, &item_info_list);
				if (da_err != SYNC_AGENT_DA_SUCCESS) {
					_DEBUG_ERROR("failed in sync_agent_get_changelog_list !!");
					err = SE_INTERNAL_NO_MEMORY;
					goto error;
				}

				pChangedDatastore = create_changed_datastore(datastoreinfo_per_content_type[content_type]->source, datastoreinfo_per_content_type[content_type]->target, 1, g_list_length(item_info_list));

				if (pChangedDatastore == NULL) {
					sync_agent_free_changelog_list(item_info_list);
					_DEBUG_ERROR("failed in create_ChangedDatastore");
					err = SE_INTERNAL_NO_MEMORY;
					goto error;
				}

				/*gathering changelog info */
				if (g_list_length(item_info_list) > 0) {
					char *cttype = __convert_cttype_str(datastoreinfo_per_content_type[content_type]->datastore_id);

					GList *item_info_iter = NULL;
					sync_agent_da_item_changelog_s *iter_data;

					for (item_info_iter = item_info_list; item_info_iter != NULL; item_info_iter = g_list_next(item_info_iter)) {
						iter_data = NULL;
						iter_data = (sync_agent_da_item_changelog_s *) (item_info_iter->data);

						if (iter_data != NULL) {
							changed_item_s *pChanged = create_changed_item(iter_data->operation_id - 300, iter_data->item_id);
							if (pChanged == NULL) {
								sync_agent_free_changelog_list(item_info_list);
								_DEBUG_ERROR("failed in create_ChangedDatastore");
								err = SE_INTERNAL_NO_MEMORY;
								goto error;
							}

							set_changed_item_content_type(pChanged, cttype);
							set_changed_item_index_of_datastore(pChanged, content_type);
							add_changed_datastore_changed_item(pChangedDatastore, pChanged);
						} else {
							sync_agent_free_changelog_list(item_info_list);
							_DEBUG_ERROR("iter_data is NULL !!");
							err = SE_INTERNAL_NO_MEMORY;
							goto error;
						}
					}

					int *itemTypeIdList = (int *)calloc(1, sizeof(int));
					if (itemTypeIdList == NULL) {
						_DEBUG_ERROR("failed in da_set_item_changelog_wait_status_internal");
						err = SE_INTERNAL_NO_MEMORY;
						goto error;
					}

					itemTypeIdList[0] = datastoreinfo_per_content_type[content_type]->datastore_id;

					sync_agent_da_update_changelog_query_s query;
					query.option = SYNC_AGENT_DA_UPDATE_CHANGELOG_OPTION_WAIT_STATUS;
					query.folder_id_list = NULL;
					query.folder_id_count = 0;
					query.item_type_id_list = itemTypeIdList;
					query.item_type_id_count = 1;

					da_err = sync_agent_update_changelog(account_id, &query);

					sync_agent_free_changelog_list(item_info_list);

					if (itemTypeIdList != NULL)
						free(itemTypeIdList);
					if (da_err != SYNC_AGENT_DA_SUCCESS) {
						_DEBUG_ERROR("failed in sync_agent_update_changelog !!");
						err = SE_INTERNAL_DA_ERROR;
						goto error;
					}
				}
			} else if (datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_ONE_WAY_FROM_SERVER
				   || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_ONE_WAY_FROM_SERVER_BY_SERVER
				   || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_SERVER || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_SERVER_BY_SERVER) {

				if (datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_ONE_WAY_FROM_SERVER) {
					/*on resume flag into agent DB */
					err = __on_resume_flag(account_id);
					if (err != SE_INTERNAL_OK) {
						_DEBUG_ERROR("failed in __on_resume_flag");
						goto error;
					}
				}

				/*MUST create empty changedDatastore.. */
				pChangedDatastore = create_changed_datastore(datastoreinfo_per_content_type[content_type]->source, datastoreinfo_per_content_type[content_type]->target, 1, 0);
				if (pChangedDatastore == NULL) {
					_DEBUG_ERROR("pChangedDatastore is NULL");
					err = SE_INTERNAL_NO_MEMORY;
					goto error;
				}

				if (datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_SERVER || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_SERVER_BY_SERVER) {

					/*_DEBUG_TRACE("sync_agent_refresh_item_tbl_from_service");
					sync_agent_refresh_item_tbl_from_service(account_id, datastoreinfo_per_content_type[content_type]->plugin_type);*/

					/*  Delete All item (include changelog), before adapting server item data */
					_DEBUG_TRACE("sync_agent_begin_service = %d", datastoreinfo_per_content_type[content_type]->datastore_id);
					sync_agent_begin_service(datastoreinfo_per_content_type[content_type]->datastore_id);
					sync_agent_begin_transaction();

					/*delete service item data */
					sync_agent_da_delete_service_item_query_s query;
					query.content_type = datastoreinfo_per_content_type[content_type]->datastore_id;
					query.account_id = account_id;

					da_err = sync_agent_query_delete_service_items(&query);
					if (da_err != SYNC_AGENT_DA_SUCCESS) {

						sync_agent_end_service(datastoreinfo_per_content_type[content_type]->datastore_id, 0);
						sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_ROLLBACK);

						_DEBUG_ERROR("failed in sync_agent_query_delete_service_items()");
						err = SE_INTERNAL_DA_ERROR;
						goto error;
					}

					_DEBUG_TRACE("da_get_item_by_account_id_internal");
					/*get all item by account id */
					GList *item_list = NULL;
					sync_agent_da_get_item_list_query_s get_item_query;
					get_item_query.option = SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_ACCOUNT_ID;
					get_item_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;

					da_err = sync_agent_get_item_list(account_id, &get_item_query, &item_list);
					if (da_err != SYNC_AGENT_DA_SUCCESS) {
						_DEBUG_ERROR("failed in sync_agent_get_item_list !!");
					}
					_DEBUG_TRACE("item_cnt = %d", g_list_length(item_list));

					GList *item_iter = NULL;
					sync_agent_da_item_s *item_iter_data;
					for (item_iter = item_list; item_iter != NULL; item_iter = g_list_next(item_iter)) {
						item_iter_data = NULL;
						item_iter_data = (sync_agent_da_item_s *) (item_iter->data);

						GList *mapping_list = NULL;
						sync_agent_da_get_item_list_query_s mapping_query;
						mapping_query.option = SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_SERVICE_ID_MAPPING;
						mapping_query.item_id = item_iter_data->item_id;

						da_err = sync_agent_get_item_list(account_id, &mapping_query, &mapping_list);
						if (da_err != SYNC_AGENT_DA_SUCCESS) {
							_DEBUG_ERROR("failed in sync_agent_get_item_list !!");
						}

						_DEBUG_TRACE("acc_cnt = %d", g_list_length(mapping_list));

						GList *mapping_iter = NULL;
						sync_agent_da_item_s *mapping_iter_data;

						for (mapping_iter = mapping_list; mapping_iter != NULL; mapping_iter = g_list_next(mapping_iter)) {
							mapping_iter_data = NULL;
							mapping_iter_data = (sync_agent_da_item_s *) (mapping_iter->data);
							da_err = sync_agent_delete_item(mapping_iter_data->item_id, 1);
							if (da_err != SYNC_AGENT_DA_SUCCESS) {
								_DEBUG_ERROR("failed in sync_agent_delete_item !!");
							}
						}

						sync_agent_free_item_list(mapping_list);
					}

					/*delete changelog data by account id and datastore id */
					_DEBUG_TRACE("da_delete_item_changelog_by_item_type_id_internal = %d", datastoreinfo_per_content_type[content_type]->datastore_id);

					sync_agent_da_delete_changelog_query_s delete_ch_query;
					delete_ch_query.option = SYNC_AGENT_DA_DELETE_CHANGELOG_OPTION_ITEM_TYPE_ID;
					delete_ch_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;

					da_err = sync_agent_delete_changelog(account_id, &delete_ch_query);
					if (da_err != SYNC_AGENT_DA_SUCCESS) {

						sync_agent_free_item_list(item_list);

						sync_agent_end_service(datastoreinfo_per_content_type[content_type]->datastore_id, 0);
						sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_ROLLBACK);

						_DEBUG_ERROR("failed in sync_agent_delete_changelog !!");
						err = SE_INTERNAL_DA_ERROR;
						goto error;
					}

					/*delete item from item_tbl */
					_DEBUG_TRACE("da_delete_item_by_item_type_id_internal = %d", datastoreinfo_per_content_type[content_type]->datastore_id);
					sync_agent_da_delete_item_query_s delete_item_query;
					delete_item_query.option = SYNC_AGENT_DA_DELETE_ITEM_OPTION_ITEM_TYPE_ID;
					delete_item_query.account_id = account_id;
					delete_item_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;

					da_err = sync_agent_query_delete_item(&delete_item_query);
					if (da_err != SYNC_AGENT_DA_SUCCESS) {
						sync_agent_free_item_list(item_list);

						sync_agent_end_service(datastoreinfo_per_content_type[content_type]->datastore_id, 0);
						sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_ROLLBACK);

						_DEBUG_ERROR("failed in sync_agent_query_delete_item !!");
						err = SE_INTERNAL_DA_ERROR;
						goto error;
					}

					_DEBUG_TRACE("sync_agent_end_service = %d", datastoreinfo_per_content_type[content_type]->datastore_id);
					da_err = sync_agent_end_service(datastoreinfo_per_content_type[content_type]->datastore_id, 1);
					if (da_err != SYNC_AGENT_DA_SUCCESS) {

						sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_COMMIT);
						sync_agent_free_item_list(item_list);

						_DEBUG_ERROR("failed in sync_agent_end_service !!");
						err = SE_INTERNAL_DA_ERROR;
						goto error;
					}
					sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_COMMIT);
					sync_agent_free_item_list(item_list);
				}
			}
			if (datastoreinfo_per_content_type[content_type]->client_sync_type) {
				(*sync_obj)->changed_datastore = g_list_append((*sync_obj)->changed_datastore, pChangedDatastore);

				/* for prevent */
				if (pChangedDatastore != NULL) {
					set_number_of_change(datastoreinfo_per_content_type[content_type]->client_sync_result, pChangedDatastore->number_of_changes);
				} else {
					_DEBUG_ERROR("pChangedDatastore is NULL !");
				}

				operation_type_e operation_type;
				if (datastoreinfo_per_content_type[content_type]->client_sync_result->number_of_change == 0)
					operation_type = OPERATION_NOOP;
				else
					operation_type = OPERATION_ADD;
				err = __process_update(account_id, server_sync_type, SYNC_PROGRESS_SUCCESS, operation_type, content_type, false, false, datastoreinfo_per_content_type[content_type]->client_sync_result);
				if (err != SE_INTERNAL_OK) {
					_DEBUG_ERROR("Failed in process_update");
					goto error;
				}
			}
		}
	}

	_INNER_FUNC_EXIT;
	return err;

 error:

	if (pChangedDatastore != NULL) {
		free_changed_datastore(pChangedDatastore);
		pChangedDatastore = NULL;
	}

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e _prepare_pre_sync(int account_id, char *sync_mode, san_package_s * san_package, alert_type_e * sync_type)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	/*set synchronising flag into agent DB */
	err = __on_synchronising_account(account_id);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __on_synchronising_account");
		goto error;
	}

	/*get sync type */
	err = __get_sync_type(account_id, sync_type);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __get_sync_type");
		goto error;
	}

	/*init datastore_info_array */
	err = __init_datastore_info_array(account_id);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __init_datastore_info_array");
		goto error;
	}

	/*set config based on sync mode */
	err = __set_config_based_on_sync_mode(account_id, sync_mode, san_package);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __set_config_based_on_sync_mode");
		goto error;
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e __set_config_based_on_sync_mode(int account_id, char *sync_mode, san_package_s * san_package)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	int content_type;

	if (strcmp(sync_mode, DEFINE_SYNC_MODE_PUSH) == 0) {
		if (san_package != NULL) {
			int count = san_package->cnt_sync_alerts;
			_DEBUG_TRACE("count = %d", count);
			int i;
			for (i = 0; i < count; i++) {
				for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {

					if (datastoreinfo_per_content_type[content_type] != NULL) {
						_DEBUG_TRACE("datastoreinfo_per_content_type[content_type]->target = %s", datastoreinfo_per_content_type[content_type]->target);
						if (datastoreinfo_per_content_type[content_type]->target == NULL)
							continue;

						if (strcmp(san_package->sync_alerts[i].server_uri, datastoreinfo_per_content_type[content_type]->target) == 0) {
							datastoreinfo_per_content_type[content_type]->client_sync_type = san_package->sync_alerts[i].sync_type;
							_DEBUG_TRACE("san_package->syncAlerts[i].sync_type = %d", san_package->sync_alerts[i].sync_type);
						} else
							datastoreinfo_per_content_type[content_type]->client_sync_type = ALERT_UNKNOWN;
					}
				}
			}
		}
	}

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e _execute_pre_sync(int account_id, int session_time, pre_sync_return_obj_s * pre_sync_return_obj, alert_type_e * server_sync_type)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	/*if there is no alert command from server check it and goto fail_part */
	if (g_list_length(pre_sync_return_obj->datastore_info) == 0) {
		_DEBUG_TRACE("alert command list from server is empty");
		err = SE_INTERNAL_MISCONFIGURATION;
		goto error;
	}

	err = __execute_pre_sync_set_server_id(account_id, pre_sync_return_obj->dev_id);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __set_server_id");
		goto error;
	}

	err = __execute_pre_sync_datastore(account_id, session_time, pre_sync_return_obj->datastore_info, server_sync_type);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __process_datastore");
		goto error;
	}

 error:

	_INNER_FUNC_EXIT;
	return err;

}

static se_error_type_e __execute_pre_sync_set_server_id(int account_id, char *dev_id)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	bool result;
	char *value = NULL;

	if (dev_id != NULL) {
		result = get_config(account_id, DEFINE_CONFIG_KEY_PROFILE_SERVER_ID, &value);
		if (result == true) {
			if (value != NULL) {
				if (strcmp(value, dev_id) == 0) {
					/* OK */
				} else {
					result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_SERVER_ID, dev_id, "string", "SE");
					if (result == false) {
						_DEBUG_ERROR("failed in set_Config");
						err = SE_INTERNAL_DA_ERROR;
						goto error;
					}
				}
			} else {
				result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_SERVER_ID, dev_id, "string", "SE");
				if (result == false) {
					_DEBUG_ERROR("failed in set_Config");
					err = SE_INTERNAL_DA_ERROR;
					goto error;
				}
			}
		} else {
			_DEBUG_ERROR("failed in get_Config");
			err = SE_INTERNAL_DA_ERROR;
			goto error;
		}
	}
 error:

	if (value != NULL) {
		free(value);
		value = NULL;
	}

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e __execute_pre_sync_datastore(int account_id, int session_time, GList * datastore_info, alert_type_e * server_sync_type)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	int result;

	bool changeSyncType = false;
	alert_type_e sync_type = ALERT_UNKNOWN;

	int content_type;
	GList *serverDatastore_iter = NULL;
	datastore_info_s *serverDatastoreInfo = NULL;
	bool existInServerDatastore;
	for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
		existInServerDatastore = false;

		if (datastoreinfo_per_content_type[content_type] != NULL) {
			if (datastoreinfo_per_content_type[content_type]->client_sync_type) {
				_DEBUG_VERBOSE("datastoreinfo_per_content_type[%d]->client_sync_type = %d", content_type, datastoreinfo_per_content_type[content_type]->client_sync_type);

				for (serverDatastore_iter = datastore_info; serverDatastore_iter != NULL; serverDatastore_iter = g_list_next(serverDatastore_iter)) {
					serverDatastoreInfo = serverDatastore_iter->data;

					if (strcmp(serverDatastoreInfo->source, datastoreinfo_per_content_type[content_type]->target) == 0) {
						existInServerDatastore = true;

						if (serverDatastoreInfo->next_anchor != NULL)
							datastoreinfo_per_content_type[content_type]->next_anchor_server = strdup(serverDatastoreInfo->next_anchor);

						datastoreinfo_per_content_type[content_type]->server_sync_type = serverDatastoreInfo->sync_type;

						if (datastoreinfo_per_content_type[content_type]->client_sync_type != datastoreinfo_per_content_type[content_type]->server_sync_type) {
							changeSyncType = true;
							sync_type = datastoreinfo_per_content_type[content_type]->server_sync_type;
						}

						_DEBUG_VERBOSE("datastoreinfo_per_content_type[%d]->server_sync_type = %d", content_type, datastoreinfo_per_content_type[content_type]->server_sync_type);

						if (datastoreinfo_per_content_type[content_type]->last_anchor_server) {
							/*if (strcmp(datastoreinfo_per_content_type[content_type]->lastAnchorServer, serverDatastoreInfo->lastAnchor) != 0) {
							   free(datastoreinfo_per_content_type[content_type]->lastAnchorServer);
							   datastoreinfo_per_content_type[content_type]->lastAnchorServer = NULL;
							   datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_SLOW_SYNC;
							   } */
						} else {
							/* When first synchronize, lastAnchorServer is NULL...
							   if (datastoreinfo_per_content_type[content_type]->server_sync_type != ALERT_SLOW_SYNC
							   && datastoreinfo_per_content_type[content_type]->server_sync_type != ALERT_REFRESH_FROM_CLIENT
							   && datastoreinfo_per_content_type[content_type]->server_sync_type != ALERT_REFRESH_FROM_CLIENT_BY_SERVER
							   && datastoreinfo_per_content_type[content_type]->server_sync_type != ALERT_REFRESH_FROM_SERVER
							   && datastoreinfo_per_content_type[content_type]->server_sync_type != ALERT_REFRESH_FROM_SERVER_BY_SERVER) {
							   _DEBUG_VERBOSE("sync_agent_refresh_item_tbl_from_service");
							   sync_agent_refresh_item_tbl_from_service(account_id, datastoreinfo_per_content_type[content_type]->plugin_type);
							   } */
						}
						break;
					}
				}

				if (!existInServerDatastore) {
					/* datastore config is wrong this datastore is not going to contain sync process from now */
					err = __process_update(account_id, ALERT_UNKNOWN, SYNC_FAILED_DB_CONFIG, OPERATION_NOOP, content_type, false, true, datastoreinfo_per_content_type[content_type]->client_sync_result);
					if (err != SE_INTERNAL_OK) {
						_DEBUG_ERROR("failed to process_update");
						goto error;
					}

					err = __process_update(account_id, ALERT_UNKNOWN, SYNC_FAILED_DB_CONFIG, OPERATION_NOOP, content_type, true, true, datastoreinfo_per_content_type[content_type]->server_sync_result);
					if (err != SE_INTERNAL_OK) {
						_DEBUG_ERROR("failed to process_update");
						goto error;
					}

					/* set fail into result (both client and server) */
					if (datastoreinfo_per_content_type[content_type]->client_sync_result != NULL)
						datastoreinfo_per_content_type[content_type]->client_sync_result->session_result = SYNC_SESSION_FAILED;
					if (datastoreinfo_per_content_type[content_type]->server_sync_result != NULL)
						datastoreinfo_per_content_type[content_type]->server_sync_result->session_result = SYNC_SESSION_FAILED;

					err = ___write_sync_resource_info(account_id, content_type, session_time, 0, datastoreinfo_per_content_type[content_type]->client_sync_result, datastoreinfo_per_content_type[content_type]->server_sync_result);
					if (err != SE_INTERNAL_OK) {
						_DEBUG_ERROR("failed to write_SyncResourceInfo");
						goto error;
					}

					free_datastore(datastoreinfo_per_content_type[content_type]);
					datastoreinfo_per_content_type[content_type] = NULL;

					datastore_s *datastore = NULL;
					err = __init_datastore_info(account_id, content_type, &datastore);
					if (err != SE_INTERNAL_OK) {
						_DEBUG_ERROR("failed to init_datastore_info");
						goto error;
					}

					datastoreinfo_per_content_type[content_type] = datastore;
				}
			}
		}
	}

	if (changeSyncType) {
		*server_sync_type = sync_type;
		result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_SERVER_SYNC_TYPE, __convert_sync_type_str(sync_type), "string", "SE");
		if (result == false) {
			_DEBUG_ERROR("failed in set_config");
			err = SE_INTERNAL_DA_ERROR;
			goto error;
		}
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e _execute_sync(int account_id, alert_type_e client_sync_type, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	if (client_sync_type == ALERT_TWO_WAY || client_sync_type == ALERT_TWO_WAY_BY_SERVER || client_sync_type == ALERT_ONE_WAY_FROM_CLIENT || client_sync_type == ALERT_ONE_WAY_FROM_CLIENT_BY_SERVER) {

		err = __execute_sync_arrange_changelog(account_id, client_sync_type, (*sync_return_obj)->status);
		if (err != SE_INTERNAL_OK) {
			_DEBUG_ERROR("failed to process_update");
			goto error;
		}
	}

	err = __execute_sync_status(account_id, server_sync_type, sync_obj, sync_return_obj);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __execute_sync_status");
		goto error;
	}

	err = __execute_sync_change(account_id, server_sync_type, sync_obj, sync_return_obj);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __execute_sync_change");
		goto error;
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e __execute_sync_arrange_changelog(int account_id, alert_type_e sync_type, GList * status)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	sync_agent_da_return_e da_err;

	int i = 0;
	int count = 0;
	int list_length = g_list_length(status);
	char **itemIdList = (char **)calloc(list_length, sizeof(char *));
	if (itemIdList == NULL) {
		_DEBUG_ERROR("Failed to alloc memory");
		err = SE_INTERNAL_NO_MEMORY;
		goto error;
	}

	GList *appliedStatus_iter = NULL;
	applied_status_s *pAppliedStatus = NULL;
	for (appliedStatus_iter = status; appliedStatus_iter != NULL; appliedStatus_iter = g_list_next(appliedStatus_iter)) {
		pAppliedStatus = appliedStatus_iter->data;

		switch (pAppliedStatus->status) {
		case 200:
		case 201:
		case 202:
		case 203:
		case 204:
		case 205:
		case 207:
		case 208:
		case 209:
		case 210:
		case 211:
			{
				/*clean up change log */
				if (pAppliedStatus->luid != NULL)
					itemIdList[count++] = strdup(pAppliedStatus->luid);

				if (sync_type == ALERT_TWO_WAY || sync_type == ALERT_TWO_WAY_BY_SERVER || sync_type == ALERT_ONE_WAY_FROM_CLIENT || sync_type == ALERT_ONE_WAY_FROM_CLIENT_BY_SERVER) {

					if (pAppliedStatus->change_type == CHANGE_DELETE) {
						da_err = sync_agent_delete_item(pAppliedStatus->luid, 0);
						if (da_err != SYNC_AGENT_DA_SUCCESS) {
							_DEBUG_ERROR("failed in da_delete_item_by_item_id_internal");
							err = SE_INTERNAL_DA_ERROR;
							goto error;
						}
					}
				}
				break;
			}
		case 206:
		case 420:
			break;
		case 400:
		case 500:
			{
				sync_agent_da_item_changelog_s *get_changelog = NULL;
				da_err = sync_agent_create_changelog(&get_changelog);
				if (da_err != SYNC_AGENT_DA_SUCCESS) {
					_DEBUG_ERROR("failed in sync_agent_create_changelog !!");
					err = SE_INTERNAL_DA_ERROR;
					goto error;
				}

				da_err = sync_agent_get_changelog(account_id, pAppliedStatus->luid, &get_changelog);
				if (da_err == SYNC_AGENT_DA_ERR_NO_DATA) {
					_DEBUG_VERBOSE("%s item does not exist in ChangeLog tbl", pAppliedStatus->luid);
					sync_agent_free_changelog(get_changelog);
					break;
				} else if (da_err != SYNC_AGENT_DA_SUCCESS) {
					_DEBUG_ERROR("failed in sync_agent_get_changelog !!");
					sync_agent_free_changelog(get_changelog);
					err = SE_INTERNAL_DA_ERROR;
					goto error;
				}

				if (get_changelog->status != NULL) {
					if (strcmp(get_changelog->status, "SYNC_ERROR") == 0) {
						if (pAppliedStatus->luid != NULL)
							itemIdList[count++] = strdup(pAppliedStatus->luid);
					} else {
						sync_agent_da_item_changelog_s *set_changelog = NULL;

						da_err = sync_agent_create_changelog(&set_changelog);
						if (da_err != SYNC_AGENT_DA_SUCCESS) {
							_DEBUG_ERROR("failed in sync_agent_create_changelog !!");
							sync_agent_free_changelog(get_changelog);
							err = SE_INTERNAL_DA_ERROR;
							goto error;
						}

						set_changelog->item_id = strdup(pAppliedStatus->luid);
						set_changelog->status = strdup("SYNC_ERROR");
						set_changelog->access_name = strdup("SE");

						sync_agent_da_update_changelog_query_s update_ch_query;
						update_ch_query.option = SYNC_AGENT_DA_UPDATE_CHANGELOG_OPTION_SYNC_STATUS;
						update_ch_query.update_item = set_changelog;

						da_err = sync_agent_update_changelog(account_id, &update_ch_query);
						if (da_err != SYNC_AGENT_DA_SUCCESS) {
							_DEBUG_ERROR("failed in sync_agent_update_changelog !!");
							sync_agent_free_changelog(get_changelog);
							sync_agent_free_changelog(set_changelog);
							err = SE_INTERNAL_DA_ERROR;
							goto error;
						}

						sync_agent_free_changelog(set_changelog);
					}
				}

				sync_agent_free_changelog(get_changelog);
				break;
			}
		}
	}

	if (list_length >= 1) {
		_DEBUG_TRACE("before da_delete_item_changelog_by_item_id_list_internal");
		_DEBUG_TRACE("count = %d", count);

		sync_agent_da_delete_changelog_query_s query;
		query.option = SYNC_AGENT_DA_DELETE_CHANGELOG_OPTION_ITEM_ID_LIST;
		query.item_id_list = itemIdList;
		query.count = count;

		da_err = sync_agent_delete_changelog(account_id, &query);
		if (da_err != SYNC_AGENT_DA_SUCCESS) {
			_DEBUG_ERROR("failed in sync_agent_delete_changelog !!");
			err = SE_INTERNAL_DA_ERROR;
			goto error;
		}
	}

 error:

	/*free itemIdList */
	if (itemIdList != NULL) {
		for (i = 0; i < list_length; i++) {
			if (itemIdList[i] != NULL)
				free(itemIdList[i]);
		}
		free(itemIdList);
	}

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e __execute_sync_status(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	int content_type;
	bool existEqualItem;
	bool needToSave;
	sync_result_s *pClientSyncResult;
	GList *changedDatastore_iter = NULL;
	changed_datastore_s *pSyncChangedDatastore = NULL;
	for (changedDatastore_iter = (*sync_obj)->changed_datastore; changedDatastore_iter != NULL;) {
		pSyncChangedDatastore = (changed_datastore_s *) changedDatastore_iter->data;
		_DEBUG_VERBOSE("pChangedDatastore = %p", pSyncChangedDatastore);

		int datastoreContentType = 0;
		for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
			if (datastoreinfo_per_content_type[content_type] != NULL) {
				if (strcmp(pSyncChangedDatastore->source, datastoreinfo_per_content_type[content_type]->source) == 0) {
					datastoreContentType = content_type;
					break;
				}
			}
		}

		GList *changedItem_iter = NULL;
		changed_item_s *changedItem = NULL;
		for (changedItem_iter = pSyncChangedDatastore->sent_item; changedItem_iter != NULL;) {
			changedItem = changedItem_iter->data;

			existEqualItem = false;
			GList *appliedStatus_iter = NULL;
			applied_status_s *pAppliedStatus = NULL;
			for (appliedStatus_iter = (*sync_return_obj)->status; appliedStatus_iter != NULL; appliedStatus_iter = g_list_next(appliedStatus_iter)) {
				pAppliedStatus = appliedStatus_iter->data;

				if (strcmp(pAppliedStatus->luid, changedItem->luid) == 0) {
					add_receive_count(datastoreinfo_per_content_type[datastoreContentType]->client_sync_result, 1);

					if (pAppliedStatus->status >= 200 && pAppliedStatus->status <= 210) {
						switch (changedItem->change_type) {
						case CHANGE_ADD:
							add_add_count(datastoreinfo_per_content_type[datastoreContentType]->client_sync_result, 1);
							break;
						case CHANGE_REPLACE:
							add_replace_count(datastoreinfo_per_content_type[datastoreContentType]->client_sync_result, 1);
							break;
						case CHANGE_DELETE:
							add_delete_count(datastoreinfo_per_content_type[datastoreContentType]->client_sync_result, 1);
							break;
						default:
							break;
						}
					} else {
						/* if status is not success count it is failed */
					}

					(*sync_return_obj)->status = g_list_remove((*sync_return_obj)->status, pAppliedStatus);
					free_applied_status(pAppliedStatus);
					pAppliedStatus = NULL;

					changedItem_iter = g_list_next(changedItem_iter);

					pSyncChangedDatastore->sent_item = g_list_remove(pSyncChangedDatastore->sent_item, changedItem);
					free_changed_item(changedItem);
					changedItem = NULL;

					existEqualItem = true;
					break;
				}
			}
			if (existEqualItem == false)
				changedItem_iter = g_list_next(changedItem_iter);
		}

		changedDatastore_iter = g_list_next(changedDatastore_iter);

		needToSave = false;
		pClientSyncResult = datastoreinfo_per_content_type[datastoreContentType]->client_sync_result;
		if (pClientSyncResult->number_of_change == pClientSyncResult->received_count) {
			needToSave = true;

			if (datastoreinfo_per_content_type[datastoreContentType]->client_sync_result != NULL)
				datastoreinfo_per_content_type[datastoreContentType]->client_sync_result->session_result = SYNC_SESSION_SUCCEEDED;

			/*remove datastore from list and
			   free current ChangedDatastore it does not need anymore because all item in datastore has been sent and receive status */
			(*sync_obj)->changed_datastore = g_list_remove((*sync_obj)->changed_datastore, pSyncChangedDatastore);
			free_changed_datastore(pSyncChangedDatastore);
			pSyncChangedDatastore = NULL;
		}

		operation_type_e operation_type;
		if (datastoreinfo_per_content_type[datastoreContentType]->client_sync_result->number_of_change == 0)
			operation_type = OPERATION_NOOP;
		else
			operation_type = OPERATION_ADD;
		err = __process_update(account_id, server_sync_type, SYNC_PROGRESS_SUCCESS, operation_type, datastoreContentType, false, needToSave, datastoreinfo_per_content_type[datastoreContentType]->client_sync_result);
		if (err != SE_INTERNAL_OK) {
			_DEBUG_ERROR("failed in process_update");
			goto error;
		}
	}

 error:

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e __execute_sync_change(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;
	sync_agent_da_service_item_s *service_item = NULL;
	sync_agent_da_item_s *fw_item = NULL;
	int content_type;
	GList *f_id_list = NULL;
	sync_result_s *tempServerSyncResult = NULL;

	/* process command that from server sended to client(sync, add, replace etc...) */
	changed_datastore_s *pSyncReturnChangedDatastore = NULL;
	sending_status_s *sendingStatus = NULL;
	GList *iter = NULL;
	for (iter = (*sync_return_obj)->changed_datastore; iter != NULL;) {
		pSyncReturnChangedDatastore = (changed_datastore_s *) iter->data;

		int datastoreContentType = 0;
		for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
			if (datastoreinfo_per_content_type[content_type] != NULL) {
				if (strcmp(pSyncReturnChangedDatastore->target, datastoreinfo_per_content_type[content_type]->source) == 0) {
					datastoreContentType = content_type;
					break;
				}
			}
		}

		/*noti to UI numberOfChanges from server */
		if (pSyncReturnChangedDatastore->has_number_of_changes) {
			set_number_of_change(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result, pSyncReturnChangedDatastore->number_of_changes);

			operation_type_e operation_type;
			if (datastoreinfo_per_content_type[datastoreContentType]->server_sync_result->number_of_change == 0)
				operation_type = OPERATION_NOOP;
			else
				operation_type = OPERATION_ADD;
			err = __process_update(account_id, server_sync_type, SYNC_PROGRESS_SUCCESS, operation_type, datastoreContentType, true, false, datastoreinfo_per_content_type[datastoreContentType]->server_sync_result);
			if (err != SE_INTERNAL_OK) {
				_DEBUG_ERROR("failed in process_update");
				goto error;
			}
		}

		sendingStatus = create_sending_status(pSyncReturnChangedDatastore->target, pSyncReturnChangedDatastore->source);
		if (sendingStatus == NULL) {
			err = SE_INTERNAL_NO_MEMORY;
			_DEBUG_ERROR("failed to alloc memory");
			goto error;
		}

		/*get folderId */
		char *folderId = NULL;
		sync_agent_da_get_folder_id_list_query_s query;
		query.option = SYNC_AGENT_DA_GET_FOLDER_ID_OPTION_FOLDER_TYPE_ID;
		query.account_id = account_id;
		query.item_type_id = datastoreinfo_per_content_type[datastoreContentType]->datastore_id;
		query.folder_type_id = datastoreinfo_per_content_type[datastoreContentType]->folder_type_id;

		da_err = sync_agent_get_folder_id_list(&query, &f_id_list);
		if (da_err != SYNC_AGENT_DA_SUCCESS) {
			_DEBUG_ERROR("sync_agent_get_folder_id_list_inferface() failed !!");
			goto error;
		}

		if (g_list_length(f_id_list) > 0) {
			GList *iter = g_list_nth(f_id_list, 0);
			folderId = (char *)(iter->data);
		} else {
			_DEBUG_ERROR("failed to get folderId");
			err = SE_INTERNAL_DA_ERROR;
			goto error;
		}

		int changeItemCount = g_list_length(pSyncReturnChangedDatastore->change_item);
		if (changeItemCount > 0) {
			/*begin transaction */
			_DEBUG_VERBOSE("sync_agent_begin_service with datastoreContentType = %d", datastoreContentType);
//                      sync_agent_begin_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id);
			sync_agent_begin_transaction();

			/*back up syncresult structure for rollback case */
			tempServerSyncResult = dup_sync_result(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result);
		}

		bool needToSave = false;
		sync_result_s *pServerSyncResult = NULL;
		GList *changedIter = NULL;
		changed_item_s *changedItem = NULL;
		applied_status_s *appliedStatus = NULL;

		for (changedIter = pSyncReturnChangedDatastore->change_item; changedIter != NULL; changedIter = g_list_next(changedIter)) {
			changedItem = (changedIter->data);

			_DEBUG_VERBOSE("changedItem->changeType : %d", changedItem->change_type);
			_DEBUG_VERBOSE("changedItem->luid : %s", changedItem->luid);
			_DEBUG_VERBOSE("changedItem->content_type : %s", changedItem->content_type);
			_DEBUG_VERBOSE("changedItem->indexOfDatastore : %d", changedItem->index_of_datastore);
			_DEBUG_VERBOSE("changedItem->data : %s", changedItem->data);

			add_receive_count(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result, 1);

			bool da_fail = false;
			command_result_e returnResult = COMMAND_RESULT_INIT;
			switch (changedItem->change_type) {
			case CHANGE_ADD:
				{
					/* add to service DB */
					if (changedItem->data != NULL) {
						char *fw_id = NULL;

						da_err = sync_agent_create_service_item(&service_item);
						if ((da_err != SYNC_AGENT_DA_SUCCESS) || (service_item == NULL)) {
							_DEBUG_ERROR("failed in sync_agent_create_service_item() = %d", da_err);
							returnResult = ___convert_return_status(da_err);
							da_fail = true;
							break;
						}

						service_item->item_id = g_strdup(changedItem->luid);
						service_item->content_type = datastoreinfo_per_content_type[datastoreContentType]->datastore_id;
						service_item->account_id = account_id;
						service_item->folder_id = g_strdup(folderId);
						service_item->access_name = g_strdup("Engine");
						service_item->data = g_strdup(changedItem->data);
						sync_agent_begin_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id);

						da_err = sync_agent_add_service_item(service_item, &fw_id, false);

						sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 1);

						_DEBUG_VERBOSE("da_err = %d", da_err);

						if (da_err == SYNC_AGENT_DA_SUCCESS) {
							int acc_cnt;
							bool success = true;
							char *service_id = sync_agent_get_service_item_id(fw_id);

							GList *folder_list = NULL;
							sync_agent_da_get_folder_list_query_s query;
							query.option = SYNC_AGENT_DA_GET_FOLDER_LIST_OPTION_SERVICE_ID_MAPPING;
							query.account_id = account_id;
							query.folder_id = folderId;
							da_err = sync_agent_get_folder_list(&query, &folder_list);
							if (da_err != SYNC_AGENT_DA_SUCCESS) {
								_DEBUG_ERROR("sync_agent_get_folder_list() failed !!");
								success = false;
							}

							acc_cnt = g_list_length(folder_list);

							_DEBUG_VERBOSE("acc_cnt = %d", acc_cnt);
							if (acc_cnt > 0) {
								char **fw_item_id_list = sync_agent_generate_item_luid(1, acc_cnt);
								char **id_list = (char **)calloc(acc_cnt, sizeof(char *));
								if (id_list == NULL) {
									_DEBUG_ERROR("CALLOC failed !!!");
									success = false;
									break;
								}

								if (fw_item_id_list == NULL) {
									_DEBUG_ERROR("failed in sync_agent_generate_item_luid");
									da_err = SYNC_AGENT_DA_ERRORS;
									success = false;
								} else {
									int i = 0;
									GList *iter = NULL;
									sync_agent_da_folder_s *iter_data;

									for (iter = folder_list; iter != NULL; iter = g_list_next(iter)) {
										iter_data = NULL;
										iter_data = (sync_agent_da_folder_s *) (iter->data);

										da_err = sync_agent_create_item(&fw_item);
										if ((da_err != SYNC_AGENT_DA_SUCCESS) || (fw_item == NULL)) {
											_DEBUG_ERROR("failed in sync_agent_create_item() = %d", da_err);
											success = false;
											break;
										}

										fw_item->item_id = g_strdup(fw_item_id_list[i]);
										fw_item->data_store_id = datastoreinfo_per_content_type[datastoreContentType]->datastore_id;
										fw_item->account_id = iter_data->account_id;
										fw_item->folder_id = g_strdup(iter_data->folder_id);
										fw_item->service_id = g_strdup(service_id);
										fw_item->access_name = g_strdup("DACI_ChangeLog");

										da_err = sync_agent_add_item(fw_item, &(id_list[i]), true);
										if (fw_item != NULL)
											sync_agent_free_item(fw_item);
										free(fw_item_id_list[i]);
										free(id_list[i]);

										i++;

										_DEBUG_VERBOSE("da_err = %d", da_err);

										if (da_err != SYNC_AGENT_DA_SUCCESS) {
											success = false;
											break;
										}
									}
									if (fw_item_id_list != NULL) {
										free(fw_item_id_list);
									}
									if (id_list != NULL) {
										free(id_list);
									}
								}
							}

							if (success == true) {
								returnResult = COMMAND_RESULT_ADDED;
								add_add_count(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result, 1);
							} else {
								/*this case just fail do rollback and goto fail */
								returnResult = ___convert_return_status(da_err);
								da_fail = true;
							}
							sync_agent_free_folder_list(folder_list);

							if (service_id != NULL)
								free(service_id);

						} else if (da_err == SYNC_AGENT_DA_ERR_NOT_SUPPORTED || da_err == SYNC_AGENT_DA_ERR_INVALID_CONTENT || da_err == SYNC_AGENT_DA_ERR_ALREADY_EXIST) {
							/*just return error to server */
							returnResult = ___convert_return_status(da_err);
						} else {
							/*this case just fail do rollback and goto fail */
							returnResult = ___convert_return_status(da_err);
							da_fail = true;
						}

						if (service_item != NULL)
							sync_agent_free_service_item(service_item);

						if (fw_id != NULL)
							free(fw_id);
					} else
						returnResult = COMMAND_RESULT_COMMAND_FAIL;

					break;
				}
			case CHANGE_REPLACE:
				{
					if (changedItem->data != NULL) {
						/* update from service DB */
						da_err = sync_agent_create_service_item(&service_item);
						if (da_err != SYNC_AGENT_DA_SUCCESS || (service_item == NULL)) {
							_DEBUG_ERROR("failed in sync_agent_create_service_item() = %d", da_err);
							returnResult = ___convert_return_status(da_err);
							da_fail = true;
							break;
						}

						service_item->item_id = g_strdup(changedItem->luid);
						service_item->content_type = datastoreinfo_per_content_type[datastoreContentType]->datastore_id;
						service_item->account_id = account_id;
						service_item->folder_id = g_strdup(folderId);
						service_item->access_name = g_strdup("Engine");
						service_item->data = (const void *)g_strdup(changedItem->data);

						sync_agent_begin_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id);

						da_err = sync_agent_update_service_item(service_item, changedItem->luid, false);

						sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 1);

						_DEBUG_VERBOSE("da_err = %d", da_err);
						if (da_err == SYNC_AGENT_DA_SUCCESS) {

							GList *item_list = NULL;
							sync_agent_da_get_item_list_query_s query;
							query.option = SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_SERVICE_ID_MAPPING;
							query.item_id = changedItem->luid;

							da_err = sync_agent_get_item_list(account_id, &query, &item_list);
							if (da_err != SYNC_AGENT_DA_SUCCESS) {
								_DEBUG_ERROR("failed in sync_agent_get_item_list !!");
							}

							bool success = true;
							GList *iter = NULL;
							sync_agent_da_item_s *iter_data;

							for (iter = item_list; iter != NULL; iter = g_list_next(iter)) {
								iter_data = NULL;
								iter_data = (sync_agent_da_item_s *) (iter->data);

								da_err = sync_agent_update_item(iter_data->item_id, 1);
								if (da_err != SYNC_AGENT_DA_SUCCESS) {
									success = false;
									break;
								}
							}

							if (success == true) {
								returnResult = COMMAND_RESULT_OK;
								add_replace_count(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result, 1);
							} else {
								/*this case just fail do rollback and goto fail */
								returnResult = ___convert_return_status(da_err);
								da_fail = true;
							}

							sync_agent_free_item_list(item_list);
						} else if (da_err == SYNC_AGENT_DA_ERR_NOT_SUPPORTED || da_err == SYNC_AGENT_DA_ERR_INVALID_CONTENT) {
							/*just return error to server */
							returnResult = ___convert_return_status(da_err);
						} else {
							/*this case just fail do rollback and goto fail */
							returnResult = ___convert_return_status(da_err);
							da_fail = true;
						}

						if (service_item != NULL)
							sync_agent_free_service_item(service_item);
					} else
						returnResult = COMMAND_RESULT_COMMAND_FAIL;

					break;
				}
			case CHANGE_DELETE:
				{
					/* delete from service DB */
					GList *item_list = NULL;
					sync_agent_da_get_item_list_query_s query;
					query.option = SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_SERVICE_ID_MAPPING;
					query.item_id = changedItem->luid;

					da_err = sync_agent_get_item_list(account_id, &query, &item_list);
					if (da_err != SYNC_AGENT_DA_SUCCESS) {
						_DEBUG_ERROR("failed in sync_agent_get_item_list !!");
					}

					sync_agent_begin_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id);

					da_err = sync_agent_delete_service_item(changedItem->luid, false);

					sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 1);

					_DEBUG_VERBOSE("[sync_agent_delete_service_item] result : %d", da_err);
					if (da_err == SYNC_AGENT_DA_SUCCESS) {
						bool success = true;
						GList *iter = NULL;
						sync_agent_da_item_s *iter_data;

						for (iter = item_list; iter != NULL; iter = g_list_next(iter)) {
							iter_data = NULL;
							iter_data = (sync_agent_da_item_s *) (iter->data);

							da_err = sync_agent_delete_item(iter_data->item_id, true);
							if (da_err != SYNC_AGENT_DA_SUCCESS) {
								success = false;
								break;
							}
						}

						if (success == true) {
							returnResult = COMMAND_RESULT_DELETE_WITHOUT_ARCHIVE;
							add_delete_count(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result, 1);
						} else {
							/*this case just fail do rollback and goto fail */
							returnResult = ___convert_return_status(da_err);
							da_fail = true;
						}
					} else if (da_err == SYNC_AGENT_DA_ERR_NO_DATA || da_err == SYNC_AGENT_DA_ERR_SUB_DATA_EXIST || da_err == SYNC_AGENT_DA_ERR_INVALID_CONTENT) {
						/*just return error to server */
						returnResult = ___convert_return_status(da_err);
					} else {
						/*this case just fail do rollback and goto fail */
						returnResult = ___convert_return_status(da_err);
						da_fail = true;
					}
					sync_agent_free_item_list(item_list);
					break;
				}
			default:
				break;
			}

			if (da_fail == true) {
				/*replace syncresult when rollback happened */
				if (datastoreinfo_per_content_type[datastoreContentType]->server_sync_result != NULL)
					free(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result);

				datastoreinfo_per_content_type[datastoreContentType]->server_sync_result = tempServerSyncResult;
				tempServerSyncResult = NULL;

				_DEBUG_VERBOSE("Transaction_Rollback");
				_DEBUG_VERBOSE("sync_agent_end_service with datastoreContentType = %d", datastoreContentType);
//                              sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 0);
				sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_ROLLBACK);

				err = SE_INTERNAL_DA_ERROR;
				_DEBUG_ERROR("failed in DA");
				goto error;
			}

			appliedStatus = create_applied_status(changedItem->luid, changedItem->change_type, returnResult);
			if (appliedStatus == NULL) {
				_DEBUG_VERBOSE("Transaction_Rollback");
				_DEBUG_VERBOSE("sync_agent_end_service with datastoreContentType = %d", datastoreContentType);
//                              sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 0);
				sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_ROLLBACK);

				err = SE_INTERNAL_NO_MEMORY;
				_DEBUG_ERROR("failed to alloc memory");
				goto error;
			}
			add_sending_status_applied_status(sendingStatus, appliedStatus);
		}

		if (changeItemCount > 0) {
			/*end transaction */
			_DEBUG_VERBOSE("sync_agent_end_service with datastoreContentType = %d", datastoreContentType);
//                      sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 1);
			sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_COMMIT);
		}

		/* Do not need to send update event to ui when changeItemCount less than 0 */
		/* send update event about add, delete, replace count during this sync command */
		if (changeItemCount >= 0) {
			needToSave = false;
			pServerSyncResult = datastoreinfo_per_content_type[datastoreContentType]->server_sync_result;
			if (pServerSyncResult->number_of_change == pServerSyncResult->received_count) {
				needToSave = true;

				if (datastoreinfo_per_content_type[datastoreContentType]->server_sync_result != NULL)
					datastoreinfo_per_content_type[datastoreContentType]->server_sync_result->session_result = SYNC_SESSION_SUCCEEDED;
			}

			operation_type_e operation_type;
			if (datastoreinfo_per_content_type[datastoreContentType]->server_sync_result->number_of_change == 0)
				operation_type = OPERATION_NOOP;
			else
				operation_type = OPERATION_ADD;
			err = __process_update(account_id, server_sync_type, SYNC_PROGRESS_SUCCESS, operation_type, datastoreContentType, true, needToSave, datastoreinfo_per_content_type[datastoreContentType]->server_sync_result);
			if (err != SE_INTERNAL_OK) {
				_DEBUG_ERROR("failed in process_update");
				goto error;
			}
		}

		(*sync_obj)->sending_status = g_list_append((*sync_obj)->sending_status, sendingStatus);
		sendingStatus = NULL;

		iter = g_list_next(iter);

		(*sync_return_obj)->changed_datastore = g_list_remove((*sync_return_obj)->changed_datastore, pSyncReturnChangedDatastore);
		free_changed_datastore(pSyncReturnChangedDatastore);
		pSyncReturnChangedDatastore = NULL;

		if (tempServerSyncResult != NULL) {
			free(tempServerSyncResult);
			tempServerSyncResult = NULL;
		}
	}

 error:
	sync_agent_free_folder_id_list(f_id_list);

	if (tempServerSyncResult != NULL)
		free(tempServerSyncResult);

	/* for prevent */
	free_sending_status(sendingStatus);

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e _update_sync_result(int account_id)
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;
	int content_type;

	sync_agent_da_last_anchor_s next_anchor_info;
	for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
		if (datastoreinfo_per_content_type[content_type] != NULL) {
			if (!datastoreinfo_per_content_type[content_type]->client_sync_type)
				continue;

			next_anchor_info.access_name = "Engine";
			next_anchor_info.account_id = account_id;
			next_anchor_info.data_store_id = datastoreinfo_per_content_type[content_type]->datastore_id;
			next_anchor_info.last_anchor_client = datastoreinfo_per_content_type[content_type]->next_anchor_client;
			next_anchor_info.last_anchor_server = datastoreinfo_per_content_type[content_type]->next_anchor_server;

			da_err = sync_agent_update_last_anchor(&next_anchor_info);
			if (da_err != SYNC_AGENT_DA_SUCCESS)
				_DEBUG_ERROR("failed in da_set_last_anchor_internal");

			da_err = sync_agent_set_service_change_point(account_id, datastoreinfo_per_content_type[content_type]->datastore_id);
			if (da_err != SYNC_AGENT_DA_SUCCESS)
				_DEBUG_ERROR("failed in sync_agent_set_service_change_point");
		}
	}

	_INNER_FUNC_EXIT;
	return err;
}

static command_result_e ___convert_return_status(sync_agent_da_return_e da_err)
{
	_INNER_FUNC_ENTER;

	command_result_e returnResult = COMMAND_RESULT_INIT;
	switch (da_err) {
	case 1:		/*SYNC_AGENT_DA_SUCCESS */
		/*never comes this case
		   break; */
	case -813:		/*SYNC_AGENT_DA_ERR_ALREADY_EXIST */
		returnResult = COMMAND_RESULT_ALREADY_EXIST;	/*[A] Already exists exception */
		break;
	case -815:		/*SYNC_AGENT_DA_ERR_MEMORY_FULL *//* oma : 420 (device full exception) */
		returnResult = COMMAND_RESULT_DEVICE_FULL;	/*[AR] Device full exception */
		break;
	case -820:		/*SYNC_AGENT_DA_ERR_NOT_SUPPORTED *//* oma : 415 (unsupported media type or format exception) */
		returnResult = COMMAND_RESULT_UNSUPPORTED_TYPE;	/*[AR] Unsupported media type or format exception */
		break;
	case -819:		/*SYNC_AGENT_DA_ERR_NO_DATA *//* kies : not found, oma : 211 (item not deleted exception) */
		returnResult = COMMAND_RESULT_NOT_EXIST;	/*[D] Item not deleted exception */
		break;
	case -800:		/*SYNC_AGENT_DA_ERRORS */
	case -801:		/*SYNC_AGENT_DA_NOT_FOUND_PLUG_IN */
	case -802:		/*SYNC_AGENT_DA_ERR_OPEN_FAILED */
	case -803:		/*SYNC_AGENT_DA_ERR_CLOSE_FAILED */
	case -804:		/*SYNC_AGENT_DA_ERR_TRANSACTION_FAILED */
	case -805:		/*SYNC_AGENT_DA_ERR_CREATE_TABLE_FAILED */
	case -806:		/*SYNC_AGENT_DA_ERR_DROP_TABLE_FAILED */
	case -807:		/*SYNC_AGENT_DA_ERR_QUERY_FAILED */
	case -808:		/*SYNC_AGENT_DA_ERR_NOT_OPENED */
	case -809:		/*SYNC_AGENT_DA_ERR_ACCOUNT_FULL */
	case -810:		/*SYNC_AGENT_DA_ERR_DELETE_LAST_ACCOUNT */
	case -811:		/*SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE */
	case -812:		/*SYNC_AGENT_DA_ERR_DB_HANDLER_MGR */
	case -814:		/*SYNC_AGENT_DA_ERR_INVALID_CONTENT */
	case -816:		/*SYNC_AGENT_DA_ERR_SUB_DATA_EXIST *//* oma : 427 (item not empty) */
	case -817:		/*SYNC_AGENT_DA_ERR_LOCKED *//* kies : cannot access */
	case -818:		/*SYNC_AGENT_DA_ERR_MORE_DATA */
	case -821:		/*SYNC_AGENT_DA_ERR_NOT_EXECUTE *//* kies : ex) sms send command, no network service */
	default:
		returnResult = COMMAND_RESULT_COMMAND_FAIL;	/*[ARD] Command failed exception */
		break;
	}

	_INNER_FUNC_EXIT;
	return returnResult;
}

static char *__convert_cttype_str(int datastore_id)
{
	_INNER_FUNC_ENTER;

	char *cttype = NULL;
	/*FIXME : check type and version (contact : vCard2.1 , calendar : vCalendar 1.0 , memo : plain text) of real item data.. */
	switch (datastore_id) {
	case TYPE_CONTACT:	/*contact (vCard2.1) */
		cttype = ELEMENT_TEXT_VCARD;
		break;
	case TYPE_CALENDAR:	/*calendar (vCalendar2.0) */
		cttype = ELEMENT_TEXT_VCAL;
		break;
	case TYPE_MEMO:	/*note(Memo) */
		cttype = ELEMENT_TEXT_PLAIN;
		break;
	case TYPE_CALLLOG:
		cttype = ELEMENT_TEXT_XCALLLOG;
		break;
	default:
		break;
	}

	_INNER_FUNC_EXIT;
	return cttype;
}

static int ___convert_sync_type_value(char *sync_type_str)
{
	_INNER_FUNC_ENTER;

	int sync_type_value;

	if (strcmp(sync_type_str, DEFINE_ALERT_SLOW_SYNC_STR) == 0)
		sync_type_value = ALERT_SLOW_SYNC;
	else if (strcmp(sync_type_str, DEFINE_ALERT_TWO_WAY_STR) == 0)
		sync_type_value = ALERT_TWO_WAY;
	else if (strcmp(sync_type_str, DEFINE_ALERT_ONE_WAY_FROM_CLIENT_STR) == 0)
		sync_type_value = ALERT_ONE_WAY_FROM_CLIENT;
	else if (strcmp(sync_type_str, DEFINE_ALERT_ONE_WAY_FROM_SERVER_STR) == 0)
		sync_type_value = ALERT_ONE_WAY_FROM_SERVER;
	else if (strcmp(sync_type_str, DEFINE_ALERT_REFRESH_FROM_SERVER_STR) == 0)
		sync_type_value = ALERT_REFRESH_FROM_SERVER;
	else if (strcmp(sync_type_str, DEFINE_ALERT_REFRESH_FROM_CLIENT_STR) == 0)
		sync_type_value = ALERT_REFRESH_FROM_CLIENT;
	else
		sync_type_value = ALERT_UNKNOWN;

	_INNER_FUNC_EXIT;
	return sync_type_value;
}

static char *__convert_sync_type_str(alert_type_e sync_type)
{
	_INNER_FUNC_ENTER;

	char *sync_Type = NULL;

	switch (sync_type) {
	case ALERT_TWO_WAY:
		sync_Type = DEFINE_ALERT_TWO_WAY_STR;
		break;
	case ALERT_SLOW_SYNC:
		sync_Type = DEFINE_ALERT_SLOW_SYNC_STR;
		break;
	case ALERT_ONE_WAY_FROM_CLIENT:
		sync_Type = DEFINE_ALERT_ONE_WAY_FROM_CLIENT_STR;
		break;
	case ALERT_REFRESH_FROM_CLIENT:
		sync_Type = DEFINE_ALERT_REFRESH_FROM_CLIENT_STR;
		break;
	case ALERT_ONE_WAY_FROM_SERVER:
		sync_Type = DEFINE_ALERT_ONE_WAY_FROM_SERVER_STR;
		break;
	case ALERT_REFRESH_FROM_SERVER:
		sync_Type = DEFINE_ALERT_REFRESH_FROM_SERVER_STR;
		break;
	default:
		sync_Type = DEFINE_ALERT_UNKNOWN_STR;
		break;
	}

	_INNER_FUNC_EXIT;
	return sync_Type;
}

static char *___convert_sync_progress_status_str(sync_progress_status_e progress_status)
{
	_INNER_FUNC_ENTER;

	char *progress = NULL;

	switch (progress_status) {
	case SYNC_PROGRESS_NONE:
		progress = DEFINE_PROGRESS_NONE;
		break;
	case SYNC_PROGRESS_SUCCESS:
		progress = DEFINE_PROGRESS_SUCCESS;
		break;
	case SYNC_FAILED_DB:
		progress = DEFINE_FAILED_DB;
		break;
	case SYNC_FAILED_DB_FORBIDDEN:
		progress = DEFINE_FAILED_DB_FORBIDDEN;
		break;
	case SYNC_FAILED_DB_ITEM:
		progress = DEFINE_FAILED_DB_ITEM;
		break;
	case SYNC_FAILED_DB_CONFIG:
		progress = DEFINE_FAILED_DB_CONFIG;
		break;
	case SYNC_FAILED_DB_DEVICEFULL:
		progress = DEFINE_FAILED_DB_DEVICEFULL;
		break;
	default:
		break;
	}

	_INNER_FUNC_EXIT;
	return progress;
}

static char *___convert_operation_type_str(operation_type_e operation_type)
{
	_INNER_FUNC_ENTER;

	char *operation = NULL;

	switch (operation_type) {
	case OPERATION_NOOP:
		operation = DEFINE_NOOP;
		break;
	case OPERATION_ADD:
		operation = DEFINE_ADD;
		break;
	case OPERATION_DELETE:
		operation = DEFINE_DELETE;
		break;
	case OPERATION_MOVE:
		operation = DEFINE_MOVE;
		break;
	case OPERATION_COPY:
		operation = DEFINE_COPY;
		break;
	case OPERATION_REPLACE:
		operation = DEFINE_REPLACE;
		break;
	default:
		break;
	}

	_INNER_FUNC_EXIT;
	return operation;
}

static char *_convert_sync_progress_str(sync_progress_e process)
{
	_INNER_FUNC_ENTER;

	char *syncProcess = NULL;

	switch (process) {
	case PROGRESS_NONE:
		syncProcess = DEFINE_SYNC_PROGRESS_NONE;
		break;
	case PROGRESS_INIT:
		syncProcess = DEFINE_SYNC_INIT;
		break;
	case PROGRESS_CONNECTING:
		syncProcess = DEFINE_SYNC_CONNECTING;
		break;
	case PROGRESS_AUTHENTICATED:
		syncProcess = DEFINE_SYNC_AUTHENTICATED;
		break;
	case PROGRESS_DONE:
		syncProcess = DEFINE_SYNC_DONE;
		break;
	case PROGRESS_CANCEL:
		syncProcess = DEFINE_SYNC_CANCEL;
		break;
	case PROGRESS_ERROR:
		syncProcess = DEFINE_SYNC_ERROR;
		break;
	default:
		break;
	}

	_INNER_FUNC_EXIT;
	return syncProcess;
}

static char *_convert_sync_error_str(sync_error_e error)
{
	_INNER_FUNC_ENTER;

	char *syncError = NULL;

	switch (error) {
	case ERROR_NONE:
		syncError = DEFINE_ERROR_NONE;
		break;
	case ERROR_CONNECTION:
		syncError = DEFINE_ERROR_CONNECTION;
		break;
	case ERROR_SYNCHDR:
		syncError = DEFINE_ERROR_SYNCHDR;
		break;
	case ERROR_INTERNAL:
		syncError = DEFINE_ERROR_INTERNAL;
		break;
	case ERROR_SUSPENDED:
		syncError = DEFINE_ERROR_SUSPENDED;
		break;
	case ERROR_DB:
		syncError = DEFINE_ERROR_DB;
		break;
	case ERROR_ABORT:
		syncError = DEFINE_ERROR_ABORT;
		break;
	case ERROR_SERVER:
		syncError = DEFINE_ERROR_SERVER;
		break;
	case ERROR_MEMORY_FULL:
		syncError = DEFINE_ERROR_MEMORY_FULL;
		break;
	case ERROR_AUTHENTICATE:
		syncError = DEFINE_ERROR_AUTHENTICATE;
		break;
	case ERROR_AUTOCONFIG_NOT_SUPPORT_BY_SERVER:
		syncError = DEFINE_ERROR_AUTOCONFIG_NOT_SUPPORT_BY_SERVER;
		break;
	case ERROR_LOW_BATTERY:
		syncError = DEFINE_ERROR_LOW_BATTERY;
		break;
	default:
		break;
	}

	_INNER_FUNC_EXIT;
	return syncError;
}

static se_error_type_e _check_low_battery()
{
	_INNER_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	sync_agent_dev_return_e dci_err = SYNC_AGENT_DEV_RETURN_SUCCESS;
	char *battery_level = NULL;
	int int_battery_level = 0;

	dci_err = sync_agent_get_devinfo(1, "Battery", &battery_level);
	if (dci_err != SYNC_AGENT_DEV_RETURN_SUCCESS) {
		_DEBUG_ERROR("failed in sync_agent_get_devinfo = %d", dci_err);
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

	_DEBUG_TRACE("battery_level =%s", battery_level);

	if (battery_level != NULL) {
		int_battery_level = atoi(battery_level);

		if (int_battery_level < LOW_BATTERY_LEVEL) {
			_DEBUG_ERROR("LOW Battery = %d", int_battery_level);
			err = SE_INTERNAL_LOW_BATTERY;
			goto error;
		}
	}

 error:

	if (battery_level != NULL)
		free(battery_level);

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e _open_services()
{
	_EXTERN_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;

	int content_type;
	for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
		if (datastoreinfo_per_content_type[content_type] != NULL) {
			if (!datastoreinfo_per_content_type[content_type]->client_sync_type)
				continue;

			da_err = sync_agent_open_service(content_type);
			if (da_err != SYNC_AGENT_DA_SUCCESS) {
				_DEBUG_ERROR("sync_agent_open_service(%d) is failed", content_type);
				err = SE_INTERNAL_DA_ERROR;
				break;
			}
		}
	}

	_INNER_FUNC_EXIT;
	return err;
}

static se_error_type_e _close_services()
{
	_EXTERN_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;
	sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;

	int content_type;
	for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
		if (datastoreinfo_per_content_type[content_type] != NULL) {
			if (!datastoreinfo_per_content_type[content_type]->client_sync_type)
				continue;

			da_err = sync_agent_close_service(content_type);
			if (da_err != SYNC_AGENT_DA_SUCCESS)
				_DEBUG_ERROR("sync_agent_close_service(%d) is failed", content_type);
		}
	}

	_INNER_FUNC_EXIT;
	return err;
}

bool synchronize(int account_id, char *sync_mode, san_package_s * san_package)
{
	_EXTERN_FUNC_ENTER;

	_DEBUG_INFO("accountID = %d", account_id);
	_DEBUG_INFO("sync_mode = %s", sync_mode);

	/*FIXME remove msg file */
	int ret_val = remove(OMA_DS_MSG_PATH);
	if (ret_val < 0) {
		_DEBUG_ERROR("failed in synchronize - remove()");
	}

	/*FIXME time check */
	long t, dt;
	t = myclock();

	se_error_type_e err = SE_INTERNAL_OK;
	sync_agent_dev_return_e dci_result = SYNC_AGENT_DEV_RETURN_SUCCESS;
	sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;

	common_error_type_e errorCode = COMMON_OK;
	sync_progress_e process = PROGRESS_NONE;
	sync_error_e error = ERROR_NONE;

	alert_type_e client_sync_type = ALERT_UNKNOWN;
	alert_type_e server_sync_type = ALERT_UNKNOWN;
	int only_from_client = 0;

	int session_time = sync_agent_convert_seconds_to_utc(time(NULL));	/*lastSessionTime for resultView; */
	_DEBUG_INFO("session_time = %d", session_time);

	pre_sync_return_obj_s *pre_sync_return_obj = NULL;
	sync_obj_s *sync_obj = NULL;
	sync_return_obj_s *sync_return_obj = NULL;

	bool cancel_flag = false;
	int content_type;
	char *session_id = NULL;

	char *access_name = NULL;
	bool server_flag = false;

	char *msg = NULL;
	unsigned int msg_size;
	char *recvMsg = NULL;
	unsigned int recvMsg_size;

	sync_agent_acc_error_e acc_err = SYNC_AGENT_ACC_SUCCESS;
	sync_agent_fw_account_s *fw_account = NULL;

	dci_result = sync_agent_execute_dev_function(DEFINE_PLATFORM, "pm_lock", 3, LCD_OFF, STAY_CUR_STATE, 0);
	if (dci_result != SYNC_AGENT_DEV_RETURN_SUCCESS) {
		_DEBUG_ERROR("failed in sync_agent_execute_dev_function lock = %d", dci_result);
	}

	/* low battery check */
	err = _check_low_battery();
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("check_low_battery = %d", err);
		goto fail_part;
	}

	da_err = sync_agent_open_agent();
	if (da_err != SYNC_AGENT_DA_SUCCESS) {
		_DEBUG_ERROR("failed in sync_agent_open_agent = %d", da_err);
		err = SE_INTERNAL_DA_ERROR;
		goto fail_part;
	}

	/* prepare for sending pre sync */
	err = _prepare_pre_sync(account_id, sync_mode, san_package, &client_sync_type);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __prepare_pre_sync = %d", err);
		goto fail_part;
	}

	/* check cancel flag */
	cancel_flag = sync_agent_check_cancel_flag();
	if (cancel_flag) {
		err = SE_INTERNAL_CANCEL;
		_DEBUG_INFO("cancle flag is on");
		goto cancel_part;
	}

	pre_sync_return_obj = (pre_sync_return_obj_s *) calloc(1, sizeof(pre_sync_return_obj_s));
	if (pre_sync_return_obj == NULL) {
		_DEBUG_ERROR("failed to alloc memory");
		err = SE_INTERNAL_NO_MEMORY;
		goto fail_part;
	}

	acc_err = sync_agent_create_fw_account(&fw_account);
	if (acc_err != SYNC_AGENT_ACC_SUCCESS) {
		_DEBUG_ERROR("failed in sync_agent_create_fw_account");
		err = SE_INTERNAL_NO_MEMORY;
		goto fail_part;
	}

	acc_err = sync_agent_get_fw_account(account_id, &fw_account);
	if (acc_err != SYNC_AGENT_ACC_SUCCESS) {
		_DEBUG_ERROR("failed in sync_agent_update_fw_account");
		err = SE_INTERNAL_ERROR;
		goto fail_part;
	}

	access_name = strdup(fw_account->access_name);
	if (strcmp(access_name, "DIVE") == 0) {
		server_flag = true;
	}

	/*pkg 1 */
	if (strcmp(sync_mode, DEFINE_SYNC_MODE_PUSH) == 0) {
		_DEBUG_INFO("sessionID = %d", san_package->session_id);
		session_id = g_strdup_printf("%u", san_package->session_id);	/*freed in pre_sync */
		errorCode = pre_sync(TRANSPORT_TYPE, account_id, session_id, server_flag, (void **)&pre_sync_return_obj);
	} else
		errorCode = pre_sync(TRANSPORT_TYPE, account_id, NULL, server_flag, (void **)&pre_sync_return_obj);

	/* check cancel flag */
	cancel_flag = sync_agent_check_cancel_flag();
	if (cancel_flag) {
		err = SE_INTERNAL_CANCEL;
		_DEBUG_INFO("cancle flag is on");
		goto cancel_part;
	}

	_DEBUG_INFO("pre_sync errorCode =[%d]", errorCode);
	if (errorCode != COMMON_OK) {
		err = SE_INTERNAL_SA_ERROR;
		goto fail_part;
	}

	/*execute pre_sync return */
	server_sync_type = client_sync_type;
	err = _execute_pre_sync(account_id, session_time, pre_sync_return_obj, &server_sync_type);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __process_pre_sync = %d", err);
		goto fail_part;
	}

	if (server_sync_type == ALERT_REFRESH_FROM_CLIENT || server_sync_type == ALERT_ONE_WAY_FROM_CLIENT)
		only_from_client = 1;

	_DEBUG_INFO("client_sync_type = %d", client_sync_type);
	_DEBUG_INFO("server_sync_type = %d", server_sync_type);
	_DEBUG_INFO("only_from_client = %d", only_from_client);

	_session_process(account_id, server_sync_type, PROGRESS_AUTHENTICATED, ERROR_NONE);

	/* check cancel flag */
	cancel_flag = sync_agent_check_cancel_flag();
	if (cancel_flag) {
		err = SE_INTERNAL_CANCEL;
		_DEBUG_INFO("cancle flag is on");
		goto cancel_part;
	}

	err = _open_services();
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __prepare_pre_sync = %d", err);
		goto fail_part;
	}

	/* pkg 3 */
	_DEBUG_INFO("pre_sync end pkg3 start");
	sync_obj = (sync_obj_s *) calloc(1, sizeof(sync_obj_s));
	if (sync_obj == NULL) {
		_DEBUG_ERROR("failed to alloc memory");
		err = SE_INTERNAL_NO_MEMORY;
		goto fail_part;
	}

	sync_return_obj = (sync_return_obj_s *) calloc(1, sizeof(sync_return_obj_s));
	if (sync_return_obj == NULL) {
		_DEBUG_ERROR("failed to alloc memory");
		err = SE_INTERNAL_NO_MEMORY;
		goto fail_part;
	}

	err = _assemble_changed_datastores(account_id, server_sync_type, &sync_obj);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __assemble_changeddatastore = %d", err);
		goto fail_part;
	}

	/* check cancel flag */
	cancel_flag = sync_agent_check_cancel_flag();
	if (cancel_flag) {
		err = SE_INTERNAL_CANCEL;
		_DEBUG_INFO("cancle flag is on");
		goto cancel_part;
	}

	int isFinish = 0;
	while (!isFinish) {

		errorCode = generate_msg((void **)&sync_obj, server_flag, &msg, &msg_size);
		if (errorCode != COMMON_OK) {
			_DEBUG_ERROR("Failed in generate_Msg = %d", errorCode);
			err = SE_INTERNAL_SA_ERROR;
			goto fail_part;
		}

		errorCode = exchange_msg(TRANSPORT_TYPE, msg, msg_size, &recvMsg, &recvMsg_size);
		if (errorCode != COMMON_OK) {
			_DEBUG_ERROR("Failed in exchange_Msg = %d", errorCode);
			if (errorCode == COMMON_CANCEL) {
				bool cancel_status = check_cancel_status();
				if (cancel_status) {
					err = SE_INTERNAL_SUSPEND;
					_DEBUG_INFO("cancel_status is on");
					goto suspend_part;
				}
			} else {
				err = SE_INTERNAL_SA_ERROR;
				goto fail_part;
			}
		}

		/* check cancel flag */
		cancel_flag = sync_agent_check_cancel_flag();
		if (cancel_flag) {
			bool cancel_status = check_cancel_status();
			if (cancel_status) {
				err = SE_INTERNAL_SUSPEND;
				_DEBUG_INFO("cancel_status is on");
				goto suspend_part;
			}
		}

		errorCode = process_recv_msg(recvMsg, recvMsg_size, only_from_client, (void **)&sync_return_obj, &isFinish);
		if (errorCode != COMMON_OK) {
			_DEBUG_ERROR("Failed in processRecv_Msg = %d", errorCode);
			err = SE_INTERNAL_SA_ERROR;
			goto fail_part;
		}

		err = _execute_sync(account_id, client_sync_type, server_sync_type, &sync_obj, &sync_return_obj);
		if (err != SE_INTERNAL_OK) {
			_DEBUG_ERROR("failed in __execute_sync = %d", err);
			goto fail_part;
		}

		free_changed_datastores(sync_return_obj->changed_datastore);
		sync_return_obj->changed_datastore = NULL;

		free_applied_statuses(sync_return_obj->status);
		sync_return_obj->status = NULL;

		if (msg != NULL) {
			free(msg);
			msg = NULL;
		}

		if (recvMsg != NULL) {
			free(recvMsg);
			recvMsg = NULL;
		}
	}

	err = _update_sync_result(account_id);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in __update_anchor = %d", err);
		goto fail_part;
	}

	_write_sync_data(account_id, client_sync_type, SYNC_SESSION_SUCCEEDED, session_time, only_from_client);

	goto return_part;

 suspend_part:

	errorCode = suspend_sync(TRANSPORT_TYPE, account_id, server_flag);

	if (errorCode != COMMON_OK) {
		_DEBUG_ERROR("failed in suspend_sync = %d",errorCode);

		err = SE_INTERNAL_SA_ERROR;
		if (errorCode == COMMON_SUSPEND_FAIL)
			_off_resume_flag(account_id);

		goto fail_part;
	}

 cancel_part:

	/*clean up for SA unusual end sync process case */
	clean_up_sa();

	for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
		if (datastoreinfo_per_content_type[content_type] != NULL) {
			if (datastoreinfo_per_content_type[content_type]->client_sync_type) {
				if (datastoreinfo_per_content_type[content_type]->client_sync_result != NULL)
					datastoreinfo_per_content_type[content_type]->client_sync_result->session_result = SYNC_SESSION_STOPPED;

				if (datastoreinfo_per_content_type[content_type]->server_sync_result != NULL)
					datastoreinfo_per_content_type[content_type]->server_sync_result->session_result = SYNC_SESSION_STOPPED;

			}
		}
	}

	_write_sync_data(account_id, client_sync_type, SYNC_SESSION_STOPPED, session_time, only_from_client);

	goto return_part;

 fail_part:

	/*clean up for SA unusual end sync process case */
	clean_up_sa();

	for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
		if (datastoreinfo_per_content_type[content_type] != NULL) {
			if (datastoreinfo_per_content_type[content_type]->client_sync_type) {
				if (datastoreinfo_per_content_type[content_type]->client_sync_result != NULL)
					datastoreinfo_per_content_type[content_type]->client_sync_result->session_result = SYNC_SESSION_FAILED;

				if (datastoreinfo_per_content_type[content_type]->server_sync_result != NULL)
					datastoreinfo_per_content_type[content_type]->server_sync_result->session_result = SYNC_SESSION_FAILED;
			}
		}
	}

	_write_sync_data(account_id, client_sync_type, SYNC_SESSION_FAILED, session_time, only_from_client);

 return_part:

	if (err == SE_INTERNAL_SA_ERROR)
		convert_common_errorcode(errorCode, &process, &error);
	else
		convert_engine_errorcode(err, &process, &error);

	/* off when session finish normal or cancel case(not suspend) */
	if (err != SE_INTERNAL_SUSPEND)
		_off_resume_flag(account_id);

	_off_synchronising_account(account_id);

	_session_process(account_id, server_sync_type, process, error);
	_DEBUG_INFO("server_sync_type = %d", server_sync_type);
	_DEBUG_INFO("process = %d", process);
	_DEBUG_INFO("error = %d", error);

	sync_agent_close_agent();
	_close_services();

	dci_result = sync_agent_execute_dev_function(DEFINE_PLATFORM, "pm_unlock", 2, LCD_OFF, RESET_TIMER);
	if (dci_result != SYNC_AGENT_DEV_RETURN_SUCCESS) {
		_DEBUG_ERROR("failed in sync_agent_execute_dev_function unlock");
	}

	sync_agent_free_fw_account(fw_account);

	if (access_name != NULL) {
		free(access_name);
		access_name = NULL;
	}

	if (msg != NULL) {
		free(msg);
		msg = NULL;
	}

	if (recvMsg != NULL) {
		free(recvMsg);
		recvMsg = NULL;
	}

	if (pre_sync_return_obj != NULL) {
		free_pre_sync_return_obj(pre_sync_return_obj);
		pre_sync_return_obj = NULL;
	}

	if (sync_obj != NULL) {
		free_sync_obj(sync_obj);
		sync_obj = NULL;
	}

	if (sync_return_obj != NULL) {
		free_sync_return_obj(sync_return_obj);
		sync_return_obj = NULL;
	}

	for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
		if (datastoreinfo_per_content_type[content_type] != NULL) {
			free_datastore(datastoreinfo_per_content_type[content_type]);
			datastoreinfo_per_content_type[content_type] = NULL;
		}
	}

	 /*FIXME*/ dt = myclock() - t;
	_DEBUG_ERROR("\n=============TOTAL---- % d . % d sec\n", dt / 1000, dt % 1000);

	_EXTERN_FUNC_EXIT;
	if (err != SE_INTERNAL_OK)
		return false;
	else
		return true;
}

void convert_common_errorcode(common_error_type_e errorCode, sync_progress_e * process, sync_error_e * error)
{
	_EXTERN_FUNC_ENTER;

	switch (errorCode) {
	case COMMON_OK:	/*ERROR_INTERNAL_OK */
		{
			/* Do nothing : Error None
			 * pre_sync : PROGRESS_AUTHENTICATED
			 * sync end : PROGRESS_DONE
			 process = PROGRESS_AUTHENTICATED;
			 process = PROGRESS_DONE;
			 */
			*process = PROGRESS_DONE;
			*error = ERROR_NONE;
		}
		break;
	case COMMON_SUSPEND_FAIL:
	case COMMON_CANCEL:
		{
			*process = PROGRESS_CANCEL;
			*error = ERROR_NONE;
		}
		break;
	case COMMON_MISCONFIGURATION:	/*ERROR_INTERNAL_MISCONFIGURATION : need configure infomation (account_id, id, pw, server_url...) */
		{
			*process = PROGRESS_ERROR;
			*error = ERROR_SYNCHDR;
		}
		break;
	case COMMON_AUTHENTICATION_ERROR:	/*ERROR_AUTH_REQUIRED, ERROR_AUTH_REJECTED */
		{
			*process = PROGRESS_ERROR;
			*error = ERROR_AUTHENTICATE;
		}
		break;
	case COMMON_NOT_FOUND:	/*ERROR_NOT_FOUND (ERROR_INTERNAL ??) */
		{
			*process = PROGRESS_ERROR;
			*error = ERROR_SYNCHDR;
		}
		break;
	case COMMON_NO_MEMORY:	/*ERROR_INTERNAL_NO_MEMORY */
		{
			*process = PROGRESS_ERROR;
			*error = ERROR_MEMORY_FULL;
		}
		break;
	case COMMON_INTERNAL_ERROR:	/*ERROR_INTERNAL_NOT_DEFINED || ERROR_INTERNAL_BINDER_ERROR */
		{
			*process = PROGRESS_ERROR;
			*error = ERROR_INTERNAL;
		}
		break;
	case COMMON_SERVER_ERROR:	/*ERROR_GENERIC || ERROR_SERVER_FAILURE */
		{
			*process = PROGRESS_ERROR;
			*error = ERROR_SERVER;
		}
		break;
	case COMMON_CONNECTION_ERROR:	/*ERROR_INTERNAL_CONNECTION_ERROR */
		{
			*process = PROGRESS_ERROR;
			*error = ERROR_CONNECTION;
		}
		break;
	case COMMON_AUTOCONFIG_NOT_SUPPORT_BY_SERVER:	/*ERROR_INTERNAL_AUTOCONFIG_NOT_SUPPORT_BY_SERVER */
		{
			*process = PROGRESS_ERROR;
			*error = ERROR_AUTOCONFIG_NOT_SUPPORT_BY_SERVER;
		}
		break;
	default:
		{
			*process = PROGRESS_ERROR;
			*error = ERROR_INTERNAL;	/*?? unknown error */
		}
		break;
	}

	_EXTERN_FUNC_EXIT;
}

void convert_engine_errorcode(se_error_type_e err, sync_progress_e * process, sync_error_e * error)
{
	_EXTERN_FUNC_ENTER;

	switch (err) {
	case SE_INTERNAL_OK:
		*process = PROGRESS_DONE;
		*error = ERROR_NONE;
		break;
	case SE_INTERNAL_SUSPEND:
	case SE_INTERNAL_CANCEL:
		*process = PROGRESS_CANCEL;
		*error = ERROR_NONE;
		break;
	case ERROR_UNKNOWN:
	case SE_INTERNAL_SA_ERROR:
	case SE_INTERNAL_SCHEDULER_ERROR:
	case SE_INTERNAL_ENGINE_CONTROLER_ERROR:
	case SE_INTERNAL_EVENT_ERROR:
	case SE_INTERNAL_NOT_DEFINED:
	case SE_INTERNAL_ERROR:
		*process = PROGRESS_ERROR;
		*error = ERROR_INTERNAL;
		break;
	case SE_INTERNAL_NO_MEMORY:
		*process = PROGRESS_ERROR;
		*error = ERROR_MEMORY_FULL;
		break;
	case SE_INTERNAL_DA_ERROR:
		*process = PROGRESS_ERROR;
		*error = ERROR_DB;
		break;
	case SE_INTERNAL_MISCONFIGURATION:
		*process = PROGRESS_ERROR;
		*error = ERROR_SYNCHDR;
		break;
	case SE_INTERNAL_LOW_BATTERY:
		*process = PROGRESS_ERROR;
		*error = ERROR_LOW_BATTERY;
		break;
	}

	_EXTERN_FUNC_EXIT;
}

se_error_type_e session_process(char *profileDirName, alert_type_e server_sync_type, sync_progress_e process, sync_error_e error)
{
	_EXTERN_FUNC_ENTER;

	_DEBUG_INFO("profileDirName = %s", profileDirName);
	_DEBUG_INFO("process = %d", process);
	_DEBUG_INFO("error = %d", error);

	se_error_type_e err = SE_INTERNAL_OK;

	char *sync_type = NULL;
	char *syncProcess = NULL;
	char *syncError = NULL;
	int sync_type_value = 0;

	sync_type = __convert_sync_type_str(server_sync_type);
	sync_type_value = __convert_alert_to_sync_type_value(server_sync_type);
	_DEBUG_INFO("sync_type_value: [%d]", sync_type_value);

	syncProcess = _convert_sync_progress_str(process);

	syncError = _convert_sync_error_str(error);

	if (sync_type == NULL || syncProcess == NULL || syncError == NULL) {
		err = SE_INTERNAL_NOT_DEFINED;
		goto error;
	}

	err = send_noti_session_process(profileDirName, sync_type_value, syncProcess, syncError);
	if (err != SE_INTERNAL_OK) {
		_DEBUG_ERROR("failed in send_noti_session_process");
		goto error;
	}

	_EXTERN_FUNC_EXIT;

 error:

	return err;
}

se_error_type_e reset_synchronizing_profiles()
{
	_EXTERN_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	sync_agent_acc_error_e acc_err = SYNC_AGENT_ACC_SUCCESS;
	sync_agent_fw_account_s *fw_account = NULL;
	GList *account_info_list = NULL;
	GList *iter = NULL;

	sync_agent_da_return_e da_err = sync_agent_open_agent();
	if (da_err != SYNC_AGENT_DA_SUCCESS) {
		_DEBUG_ERROR("failed in sync_agent_open_agent");
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

	sync_agent_fw_account_query_s query;
	query.query = ACCOUNT_QUERY_BY_NONE;

	acc_err = sync_agent_query_fw_account(&query, &account_info_list);
	if (acc_err != SYNC_AGENT_ACC_SUCCESS) {
		_DEBUG_ERROR("sync_agent_query_fw_account is failed");
		goto error;
	}

	for (iter = account_info_list; iter != NULL; iter = g_list_next(iter)) {
		fw_account = (sync_agent_fw_account_s *) iter->data;

		_DEBUG_INFO("account = %d", fw_account->account_id);
		_off_synchronising_account(fw_account->account_id);

		_DEBUG_INFO("construct_itemTbl From service start");

		int content_type;
		for (content_type = 0; content_type < TYPE_SERVICE_COUNT - 1; content_type++) {

			da_err = sync_agent_open_service(content_type);
			if (da_err != SYNC_AGENT_DA_SUCCESS) {
				_DEBUG_ERROR("sync_agent_open_service(%d) is failed ", content_type);
				continue;
			}

			_DEBUG_INFO("sync_agent_construct_item_tbl_from_service(%d, %d);", fw_account->account_id, content_type);
			sync_agent_construct_item_tbl_from_service(fw_account->account_id, content_type);

			da_err = sync_agent_close_service(content_type);
			if (da_err != SYNC_AGENT_DA_SUCCESS) {
				_DEBUG_ERROR("sync_agent_close_service(%d) is failed ", content_type);
				continue;
			}
		}

		_DEBUG_INFO("construct_itemTbl From service end");
	}

 error:

	sync_agent_close_agent();

	sync_agent_free_fw_account_list(account_info_list);

	_EXTERN_FUNC_EXIT;

	return err;
}

bool refresh_from_service_all(int account_id)
{
	_EXTERN_FUNC_ENTER;

	se_error_type_e err = SE_INTERNAL_OK;

	sync_agent_da_return_e da_err = sync_agent_open_agent();
	if (da_err != SYNC_AGENT_DA_SUCCESS) {
		err = SE_INTERNAL_DA_ERROR;
		goto error;
	}

	int content_type;
	for (content_type = 0; content_type < TYPE_SERVICE_COUNT - 1; content_type++) {

		da_err = sync_agent_open_service(content_type);
		if (da_err != SYNC_AGENT_DA_SUCCESS) {
			_DEBUG_ERROR("sync_agent_open_service(%d) is failed ", content_type);
			continue;
		}

		_DEBUG_INFO("sync_agent_refresh_item_tbl_from_service(%d, %d);", account_id, content_type);
		sync_agent_refresh_item_tbl_from_service(account_id, content_type);

		da_err = sync_agent_close_service(content_type);
		if (da_err != SYNC_AGENT_DA_SUCCESS) {
			_DEBUG_ERROR("sync_agent_close_service(%d) is failed ", content_type);
			continue;
		}
	}

 error:

	sync_agent_close_agent();

	_EXTERN_FUNC_EXIT;

	if (err != SE_INTERNAL_OK)
		return false;
	else
		return true;
}

se_error_type_e cancel_sync_request()
{
	_EXTERN_FUNC_ENTER;
	se_error_type_e err = SE_INTERNAL_OK;

	cancel_connection_sync_request(TRANSPORT_TYPE);

	_EXTERN_FUNC_EXIT;

	return err;
}