/*
 * 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-private.h>
#include <user-awareness-util.h>

static gboolean is_initialized = FALSE;

extern GSList *ua_monitor_list;
extern GSList *ua_user_list;
extern GSList *ua_services_list;

extern GSList *ua_users_list;
extern GSList *ua_devices_user_list;
extern GSList *ua_devices_list;

/* LCOV_EXCL_START */
static void __ua_event_handler(int event, uam_event_data_s *event_param,
	void *user_data)
{
	FUNC_ENTRY;

	ret_if(NULL == event_param);

	switch (event) {
	case UAM_EVENT_USER_PRESENCE_DETECTED: {
		uam_detection_event_data_s *event_data = NULL;
		uam_sensor_info_s *sensor_info = NULL;

		event_data = event_param->data;
		ret_if(NULL == event_data);
		ret_if(NULL == event_data->service);
		ret_if(NULL == event_data->account);
		ret_if(NULL == event_data->device_id);

		sensor_info = g_new0(uam_sensor_info_s, 1);
		ret_if(NULL == sensor_info);

		sensor_info->sensor_bitmask = event_data->sensor_bitmask;
		sensor_info->timestamp = event_data->last_seen;

		UA_INFO("sensor_info: bitmask[%u], timestamp [%llu]",
				sensor_info->sensor_bitmask, sensor_info->timestamp);

		_ua_monitor_handle_user_presence_detected(
				sensor_info, event_data->service,
				event_data->account, event_data->last_seen,
				event_data->device_id);
		g_free(sensor_info);

		break;
	}
	case UAM_EVENT_USER_ABSENCE_DETECTED: {
		uam_detection_event_data_s *event_data = NULL;
		uam_sensor_info_s *sensor_info = NULL;

		event_data = event_param->data;
		ret_if(NULL == event_data);
		ret_if(NULL == event_data->service);
		ret_if(NULL == event_data->account);

		sensor_info = g_new0(uam_sensor_info_s, 1);
		ret_if(NULL == sensor_info);

		sensor_info->sensor_bitmask = event_data->sensor_bitmask;

		UA_INFO("sensor_info: bitmask[%u]", sensor_info->sensor_bitmask);

		_ua_monitor_handle_user_absence_detected(
				sensor_info, event_data->service,
				event_data->account);
		g_free(sensor_info);

		break;
	}
	case UAM_EVENT_PRESENCE_DETECTED: {
		uam_sensor_info_s *sensor_info = NULL;

		sensor_info = event_param->data;
		ret_if(NULL == sensor_info);

		UA_INFO("sensor: [%u], timestamp [%llu], accuracy [%d], value [%f]",
				sensor_info->sensor_bitmask, sensor_info->timestamp,
				sensor_info->accuracy, sensor_info->values[0]);
		_ua_monitor_handle_user_presence_detected(sensor_info, NULL,
				NULL, 0, NULL);

		break;
	}
	case UAM_EVENT_ABSENCE_DETECTED: {
		uam_sensor_info_s *sensor_info = NULL;

		sensor_info = event_param->data;
		ret_if(NULL == sensor_info);

		UA_INFO("sensor: [%u], timestamp [%llu], accuracy [%d], value [%f]",
				sensor_info->sensor_bitmask, sensor_info->timestamp,
				sensor_info->accuracy, sensor_info->values[0]);
		_ua_monitor_handle_user_absence_detected(sensor_info, NULL, NULL);

		break;
	}
	case UAM_EVENT_SENSOR_STATUS_CHANGED: {
		uam_sensor_info_s *sensor_info = NULL;

		sensor_info = event_param->data;
		ret_if(NULL == sensor_info);

		UA_INFO("status [%d] sensor: [%u], timestamp [%llu], accuracy [%d], value [%f]",
				sensor_info->status, sensor_info->sensor_bitmask, sensor_info->timestamp,
				sensor_info->accuracy, sensor_info->values[0]);

		_ua_monitor_handle_sensor_status_changed(sensor_info);

		break;
	}
	case UAM_EVENT_DETECTION_STARTED: {
		UA_INFO("Received DETECTION STARTED event !!");
		break;
	}
	case UAM_EVENT_DETECTION_STOPPED: {
		uam_detection_stopped_event_data_s *event_data = event_param->data;
		ret_if(NULL == event_data);
		ret_if(NULL == event_data->service);

		_ua_monitor_handle_detection_stopped(event_data->service,
				event_data->cycle_state);
		break;
	}
	case UAM_EVENT_SENSOR_STATE_READY: {
		unsigned int *sensor_bitmask = event_param->data;

		ret_if(NULL == sensor_bitmask);

		_ua_monitor_handle_sensor_state(*sensor_bitmask, TRUE);
		break;
	}
	case UAM_EVENT_SENSOR_STATE_NOT_READY: {
		unsigned int *sensor_bitmask = event_param->data;

		ret_if(NULL == sensor_bitmask);
		ret_if(0 == *sensor_bitmask);

		_ua_monitor_handle_sensor_state(*sensor_bitmask, FALSE);
		break;
	}
	case UAM_EVENT_USER_ADDED: {
		uam_user_info_s *event_data = NULL;

		event_data = event_param->data;
		ret_if(NULL == event_data);

		if (_ua_user_add_info_to_list_from_uapi_data(event_data) != UA_ERROR_NONE)
			UA_ERR("Fail to add user");
		else
			UA_INFO("User Added");
		break;
	}
	case UAM_EVENT_USER_REMOVED: {
		uam_user_info_s *event_data = NULL;

		event_data = event_param->data;
		ret_if(NULL == event_data);

		if (_ua_remove_user_info_from_list(event_data->account) != UA_ERROR_NONE)
			UA_ERR("Fail to remove user");
		else
			UA_INFO("Removed user");
		break;
	}
	case UAM_EVENT_DEVICE_ADDED: {
		uam_device_info_s *dev_info = NULL;

		dev_info = event_param->data;

		_ua_handle_device_added(event_param->result, dev_info);
		break;
	}
	case UAM_EVENT_DEVICE_REMOVED: {
		uam_device_info_s *dev_info = NULL;

		dev_info = event_param->data;
		ret_if(NULL == dev_info);

		_ua_handle_device_removed(event_param->result, dev_info);
		break;
	}
	case UAM_EVENT_SERVICE_REGISTERED: {
		uam_service_info_s *event_data = NULL;

		event_data = event_param->data;
		ret_if(NULL == event_data);

		if (_ua_service_add_info_to_list_from_uam_data(event_data) != UA_ERROR_NONE)
			UA_ERR("Fail to add service");
		else
			UA_INFO("Service Added");
		break;
	}
	case UAM_EVENT_SERVICE_UNREGISTERED: {
		uam_service_info_s *event_data = NULL;

		event_data = event_param->data;
		ret_if(NULL == event_data);

		if (_ua_service_remove_info_from_list(event_data) != UA_ERROR_NONE)
			UA_ERR("Fail to remove service");
		else
			UA_INFO("Removed service");
		break;
	}
	case UAM_EVENT_DEVICE_FOUND: {
		uam_device_info_s *dev_info = NULL;

		dev_info = event_param->data;
		ret_if(NULL == dev_info);

		_ua_monitor_handle_scanned_device(event_param->result, dev_info);
		break;
	}

	case UAM_EVENT_SCAN_COMPLETED: {
		_ua_monitor_handle_scan_complete(event_param->result);
		break;
	}

	default:
		UA_WARN("Unknown Event received");
		break;
	}

	FUNC_EXIT;
}
/* LCOV_EXCL_STOP */

static bool __foreach_added_device_cb(
		ua_device_h handle, void *user_data)
{
	int ret;
	ua_dev_info_s* dev_info;
	retv_if(NULL == handle, false);

	dev_info = (ua_dev_info_s*)handle;

	ret = _ua_device_add_info_to_list(dev_info);

	if (ret != UA_ERROR_NONE)
		return false;
	else
		return true;

	return true;
}

static bool __foreach_intr_registered_service_info(
		ua_service_h handle, void *user_data)
{
	int ret;
	ua_service_info_s* service_info;
	retv_if(NULL == handle, false);

	service_info = (ua_service_info_s*)handle;

	ret = _ua_service_add_info_to_list(service_info);

	if (ret != UA_ERROR_NONE)
		return false;
	else
		return true;
}

static bool __foreach_intr_registered_user_info(
		ua_user_h handle, void *user_data)
{
	int ret;
	ua_user_info_s* user_info;
	retv_if(NULL == handle, false);

	user_info = (ua_user_info_s*)handle;
	/* Initial state need to be set ACTIVATE to handle absence case */
	ret = _ua_user_add_info_to_list(user_info);

	if (ret != UA_ERROR_NONE)
		return false;
	else
		return true;
}

int ua_initialize(void)
{
	FUNC_ENTRY;
	int ret;

	retv_if(TRUE == is_initialized, UA_ERROR_ALREADY_DONE);

	ret = _ua_get_error_code(_uam_init(__ua_event_handler, NULL));
	if (UA_ERROR_NONE != ret) {
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		return ret;
	}

	ret = ua_device_foreach_added(__foreach_added_device_cb, NULL);
	if (UA_ERROR_NONE != ret) {
		/* LCOV_EXCL_START */
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		return ret;
		/* LCOV_EXCL_STOP */
	}

	ret = _ua_intr_foreach_registered_services(__foreach_intr_registered_service_info, NULL);
	if (UA_ERROR_NONE != ret) {
		/* LCOV_EXCL_START */
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		return ret;
		/* LCOV_EXCL_STOP */
	}

	ret = _ua_intr_foreach_registered_users(__foreach_intr_registered_user_info, NULL);
	if (UA_ERROR_NONE != ret) {
		/* LCOV_EXCL_START */
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		return ret;
		/* LCOV_EXCL_STOP */
	}

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

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

	is_initialized = TRUE;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_deinitialize(void)
{
	FUNC_ENTRY;
	int ret;

	retv_if(TRUE != is_initialized, UA_ERROR_NOT_INITIALIZED);

	g_slist_free_full(ua_services_list, _ua_free_ua_service_info_s);
	ua_services_list = NULL;

	g_slist_free_full(ua_monitor_list, _ua_free_ua_monitor_t);
	ua_monitor_list = NULL;

	g_slist_free_full(ua_users_list, _ua_free_ua_user_info_t);
	ua_users_list = NULL;

	g_slist_free_full(ua_devices_user_list, _ua_free_ua_device_info_t);
	ua_devices_user_list = NULL;

	g_slist_free_full(ua_devices_list, _ua_free_ua_device_info_t);
	ua_devices_list = NULL;

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

	is_initialized = FALSE;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}