/*
 * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * 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.
 *
 */

#include <glib.h>
#include <ua-api.h>

#include <user-awareness.h>
#include <user-awareness-log.h>
#include <user-awareness-internal.h>
#include <user-awareness-private.h>
#include <user-awareness-util.h>

static GSList *ua_payloads_list;

int ua_payload_create(ua_payload_h *payload_handle)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = NULL;

	UA_CHECK_INIT_STATUS();
	UA_VALIDATE_INPUT_PARAMETER(payload_handle);

	payload = g_malloc0(sizeof(ua_payload_info_s));
	if (!payload) {
		/* LCOV_EXCL_START */
		UA_ERR("g_malloc0 failed");
		return UA_ERROR_OUT_OF_MEMORY;
		/* LCOV_EXCL_STOP */
	}

	/* default values */
	payload->primary_key = 13;
	payload->device_type = 1;
	payload->secondary_key = 1;
	payload->extension_value1 = 0;
	payload->extension_value2 = 0;
	payload->device_uid_len = 0;
	payload->device_uid = NULL;
	payload->isadded = false;

	/* Add payload to list of payloads*/
	*payload_handle = (ua_payload_h)payload;
	payload->handle = *payload_handle;

	ua_payloads_list = g_slist_append(ua_payloads_list, payload);

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

void _ua_free_ua_payload_info_s(gpointer data)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = data;

	ret_if(NULL == payload);

	g_free(payload->device_uid);
	g_free(payload);

	FUNC_EXIT;
}

void _ua_clear_payload_list(void)
{
	g_slist_free_full(ua_payloads_list, _ua_free_ua_payload_info_s);
	ua_payloads_list = NULL;
}

int ua_payload_destroy(ua_payload_h handle)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;

	UA_CHECK_INIT_STATUS();
	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_HANDLE(handle, ua_payloads_list);

	/* Do not remove from list if payload is added to database */
	if (payload->isadded) {
		/* LCOV_EXCL_START */
		return UA_ERROR_NONE;
		/* LCOV_EXCL_STOP */
	}

	ua_payloads_list = g_slist_remove(ua_payloads_list, payload);
	_ua_free_ua_payload_info_s(payload);

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_set_primary_key(
		ua_payload_h handle,
		const char primary_key)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;

	UA_CHECK_INIT_STATUS();
	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_PRINT_PAYLOAD_HANDLE(handle);

	payload->primary_key = primary_key;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_set_device_icon(
		ua_device_h handle,
		const char device_icon)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;

	UA_CHECK_INIT_STATUS();
	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_PRINT_PAYLOAD_HANDLE(handle);

	payload->device_type = device_icon;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_set_secondary_key(
		ua_device_h handle,
		const char secondary_key)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;

	UA_CHECK_INIT_STATUS();
	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_PRINT_PAYLOAD_HANDLE(handle);

	payload->secondary_key = secondary_key;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_set_device_uid(
		ua_device_h handle,
		unsigned int device_uid_len,
		const char *device_uid)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;

	UA_CHECK_INIT_STATUS();
	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(device_uid);
	UA_PRINT_PAYLOAD_HANDLE(handle);

	retv_if(device_uid_len > UA_BLE_PAYLOAD_DEVICE_UID_MAX_LEN, UA_ERROR_INVALID_PARAMETER);

	payload->device_uid_len = device_uid_len;
	g_free(payload->device_uid);
	payload->device_uid = NULL;

	payload->device_uid = g_malloc0(UA_BLE_PAYLOAD_DEVICE_UID_MAX_LEN + 1);
	if (payload->device_uid == NULL) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_payload_info_s((gpointer)payload);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	memcpy(payload->device_uid, device_uid, UA_BLE_PAYLOAD_DEVICE_UID_MAX_LEN);

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

void _ua_get_uam_payload_from_ua(uam_ble_payload_s *uam_payload,
	ua_payload_info_s *payload)
{
	FUNC_ENTRY;
	memset(uam_payload, 0, sizeof(uam_ble_payload_s));

	if (NULL == payload) {
		uam_payload->primary_key = 13;
		uam_payload->device_type = 1;
		uam_payload->secondary_key = 1;
		uam_payload->ext_val1 = 0;
		uam_payload->ext_val2 = 0;
		uam_payload->device_uid_len = 0;
		UA_DBG("(NULL == payload) return");
		return;
	}

	uam_payload->primary_key = payload->primary_key;
	uam_payload->device_type = payload->device_type;
	uam_payload->secondary_key = payload->secondary_key;
	uam_payload->ext_val1 = payload->extension_value1;
	uam_payload->ext_val2 = payload->extension_value2;
	uam_payload->device_uid_len = payload->device_uid_len;

	if (payload->device_uid)
		memcpy(uam_payload->device_uid, payload->device_uid, payload->device_uid_len);

	FUNC_EXIT;
}

int ua_payload_add(ua_payload_h payload_handle, ua_device_h device_handle)
{
	FUNC_ENTRY;
	int ret;
	uam_ble_payload_s uam_payload;

	ua_payload_info_s* payload_info = (ua_payload_info_s*)payload_handle;
	ua_dev_info_s* dev_info = (ua_dev_info_s*)device_handle;

	UA_VALIDATE_INPUT_PARAMETER(payload_handle);
	UA_VALIDATE_INPUT_PARAMETER(device_handle);

	UA_DBG("device_info->device_id [%s], device_info->mac [%s], device_info->type [%d]",
		dev_info->device_id, dev_info->mac, dev_info->type);

	UA_IS_EXIST(_ua_get_device_from_list(dev_info->device_id, dev_info->mac, dev_info->type));
	retv_if(dev_info->isadded == FALSE, UA_ERROR_NOT_REGISTERED);
	retv_if(payload_info->device_uid == NULL, UA_ERROR_INVALID_PARAMETER);

	_ua_get_uam_payload_from_ua(&uam_payload, payload_info);

	ret = _ua_get_error_code(_uam_request_add_payload(&uam_payload, dev_info->device_id,
							_ua_to_uam_tech_type(dev_info->type)));
	if (UA_ERROR_NONE != ret) {
		UA_ERR("_uam_request_add_payload returned %s",
				_ua_get_error_string(ret));
		return ret;
	}

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_add_service(ua_payload_h payload_handle,
		ua_service_h service_handle)
{
	FUNC_ENTRY;
	int ret;
	uam_ble_payload_s uam_payload;

	ua_payload_info_s* payload_info = (ua_payload_info_s*)payload_handle;
	ua_service_info_s* service_info = (ua_service_info_s*)service_handle;

	UA_VALIDATE_INPUT_PARAMETER(payload_handle);
	UA_VALIDATE_INPUT_PARAMETER(service_handle);
	UA_VALIDATE_INPUT_PARAMETER(service_info);

	UA_IS_EXIST(__ua_get_service_from_list(service_info->name));

	_ua_get_uam_payload_from_ua(&uam_payload, payload_info);

	ret = _ua_get_error_code(_uam_service_add_payload(service_info->name, &uam_payload));
	if (UA_ERROR_NONE != ret) {
		UA_ERR("_uam_service_add_payload returned %s",
				_ua_get_error_string(ret));
		return ret;
	}

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

ua_payload_info_s* _ua_get_payload_from_uam(uam_ble_payload_s *uam_payload)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = NULL;
	int user_data_len = 0;

	retv_if(NULL == uam_payload, NULL);

	payload = g_malloc0(sizeof(ua_payload_info_s));
	if (!payload) {
		UA_ERR("g_malloc0 failed");
		return NULL;
	}

	payload->primary_key = uam_payload->primary_key;
	payload->device_type = uam_payload->device_type;
	payload->secondary_key = uam_payload->secondary_key;
	payload->extension_value1 = uam_payload->ext_val1;
	payload->extension_value2 = uam_payload->ext_val2;

	payload->device_uid_len = uam_payload->device_uid_len;
	payload->device_uid = g_memdup(uam_payload->device_uid, uam_payload->device_uid_len);
	if (!payload->device_uid) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_payload_info_s(payload);
		return NULL;
	}

	user_data_len = UA_BLE_PAYLOAD_DEVICE_UID_MAX_LEN - 1 - uam_payload->device_uid_len;
	payload->user_data = g_memdup(uam_payload->user_data, user_data_len);
	if (!payload->user_data) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_payload_info_s(payload);
		return NULL;
	}

	FUNC_EXIT;
	return payload;
}

int _ua_foreach_added_payload(ua_added_payload_cb foreach_cb,
	void *user_data)
{
	FUNC_ENTRY;
	int i;
	int ret = UAM_ERROR_NONE;
	GSList *l;
	ua_payload_info_s *u;
	GPtrArray *payload_list = NULL;
	uam_ble_payload_s *ptr;

	UA_VALIDATE_INPUT_PARAMETER(foreach_cb);

	payload_list = g_ptr_array_new();
	retv_if(NULL == payload_list, UA_ERROR_OUT_OF_MEMORY);

	ret = _ua_get_error_code(_uam_get_added_payloads(&payload_list));
	if (UA_ERROR_NONE != ret) {
		/* LCOV_EXCL_START */
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		g_ptr_array_free(payload_list, TRUE);
		/* LCOV_EXCL_STOP */
		return ret;
	}

	if (ua_payloads_list) {
		g_slist_free_full(ua_payloads_list, _ua_free_ua_payload_info_s);
		ua_payloads_list = NULL;
	}

	for (i = 0; i < payload_list->len; i++) {
		ptr = g_ptr_array_index(payload_list, i);
		if (ptr) {
			ua_payload_info_s* payload_info;
			payload_info = _ua_get_payload_from_uam(ptr);

			payload_info->isadded = true;
			payload_info->handle = (ua_payload_h)payload_info;

			ua_payloads_list = g_slist_append(ua_payloads_list, payload_info);
		} else {
			/* LCOV_EXCL_START */
			UA_ERR("OPERATION_FAILED(0x%08x)",
					UA_ERROR_OPERATION_FAILED);
			ret = UA_ERROR_OPERATION_FAILED;
			/* LCOV_EXCL_STOP */
			goto done;
		}
	}

	for (l = ua_payloads_list; l; l = g_slist_next(l)) {
		u = (ua_payload_info_s *)l->data;

		if (!foreach_cb(u->handle, user_data))
			break;
	}

done:
	g_ptr_array_foreach(payload_list, (GFunc)g_free, NULL);
	g_ptr_array_free(payload_list, TRUE);

	FUNC_EXIT;
	return ret;
}

int ua_payload_foreach_added(
		ua_added_payload_cb foreach_cb,
		void *user_data)
{
	FUNC_ENTRY;
	UA_VALIDATE_INPUT_PARAMETER(foreach_cb);

	int ret = _ua_foreach_added_payload(foreach_cb, user_data);

	FUNC_EXIT;
	return ret;
}

ua_payload_info_s* _ua_payload_clone(ua_payload_info_s *org_payload)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = NULL;
	int user_data_len = 0;

	retv_if(NULL == org_payload, NULL);

	payload = g_malloc0(sizeof(ua_payload_info_s));
	if (!payload) {
		UA_ERR("g_malloc0 failed");
		return NULL;
	}

	payload->primary_key = org_payload->primary_key;
	payload->device_type = org_payload->device_type;
	payload->secondary_key = org_payload->secondary_key;
	payload->extension_value1 = org_payload->extension_value1;
	payload->extension_value2 = org_payload->extension_value2;

	payload->device_uid_len = org_payload->device_uid_len;
	payload->device_uid = g_memdup(org_payload->device_uid, org_payload->device_uid_len);
	if (!payload->device_uid && org_payload->device_uid) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_payload_info_s(payload);
		return NULL;
	}

	user_data_len = UA_BLE_PAYLOAD_DEVICE_UID_MAX_LEN - 1 - org_payload->device_uid_len;
	payload->user_data = g_memdup(org_payload->user_data, user_data_len);
	if (!payload->user_data && org_payload->user_data) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_payload_info_s(payload);
		return NULL;
	}

	FUNC_EXIT;
	return payload;
}

int ua_payload_clone(ua_payload_h *dst, ua_payload_h src)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload_dst = NULL;
	ua_payload_info_s *payload_src = src;

	UA_CHECK_INIT_STATUS();
	UA_VALIDATE_INPUT_PARAMETER(dst);
	UA_VALIDATE_INPUT_PARAMETER(src);

	payload_dst = _ua_payload_clone(payload_src);
	if (payload_dst == NULL && payload_src) {
		UA_ERR("g_malloc0 failed");
		return UA_ERROR_OUT_OF_MEMORY;
	}


	/* Add payload to list of payloads*/
	*dst = (ua_payload_h)payload_dst;
	payload_dst->handle = (ua_payload_h)payload_dst;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_get_primary_key(
		ua_payload_h handle,
		char *primary_key)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(primary_key);
	UA_PRINT_PAYLOAD_HANDLE(handle);

	*primary_key = payload->primary_key;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_get_secondary_key(
		ua_payload_h handle,
		char *secondary_key)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(secondary_key);
	UA_PRINT_PAYLOAD_HANDLE(handle);

	*secondary_key = payload->secondary_key;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_get_device_uid_len(
		ua_payload_h handle,
		int *device_uid_len)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(device_uid_len);
	UA_PRINT_PAYLOAD_HANDLE(handle);

	UA_DBG("payload(device_uid_len) [%d]", payload->device_uid_len);
	*device_uid_len = payload->device_uid_len;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_get_device_uid(
		ua_payload_h handle,
		char **device_uid)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(device_uid);
	UA_PRINT_PAYLOAD_HANDLE(handle);

	if (!payload->device_uid) {
		*device_uid = NULL;
		UA_DBG("payload(device_uid) is not found");
		goto done;
	}

	UA_DBG("payload(device_uid_len) [%d]", payload->device_uid_len);
	*device_uid = g_memdup(payload->device_uid, payload->device_uid_len);
	if (*device_uid == NULL) {
		// LCOV_EXCL_START
		UA_ERR("g_memdup failed");
		return UA_ERROR_OUT_OF_MEMORY;
		// LCOV_EXCL_START
	}

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_get_device_icon(
		ua_payload_h handle,
		char *device_icon)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(device_icon);
	UA_PRINT_PAYLOAD_HANDLE(handle);

	*device_icon = payload->device_type;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_payload_get_user_data(
		ua_payload_h handle,
		char **user_data)
{
	FUNC_ENTRY;
	ua_payload_info_s *payload = (ua_payload_info_s *)handle;
	int user_data_len = 0;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(user_data);
	UA_PRINT_PAYLOAD_HANDLE(handle);

	if (!payload->user_data) {
		*user_data = NULL;
		UA_DBG("payload(user_data) is not found");
		goto done;
	}

	user_data_len = UA_BLE_PAYLOAD_DEVICE_UID_MAX_LEN - 1 - payload->device_uid_len;
	*user_data = g_memdup(payload->user_data, user_data_len);
	if (*user_data == NULL) {
		// LCOV_EXCL_START
		UA_ERR("g_memdup failed");
		return UA_ERROR_OUT_OF_MEMORY;
		// LCOV_EXCL_START
	}

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}