/*
 * Copyright (c) 2016 - 2017 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 <sqlite3.h>
#include <db-util.h>
#include <gio/gio.h>
#include <string.h>
#include <pkgmgr-info.h>
#include <package_manager.h>

#include "badge_setting.h"
#include "badge_setting_service.h"
#include "badge_db.h"
#include "badge_error.h"
#include "badge_log.h"

#define BADGE_PRIVILEGE "http://tizen.org/privilege/notification"

#define BAGDE_ALLOW_TO_DISPLAY_BIT 0x1
#define BAGDE_APP_DISABLE_BIT 0x2

#define BAGDE_APP_ENABLE 0x0
#define BAGDE_APP_DISABLE 0x2

#define BAGDE_NOT_ALLOW_TO_DISPLAY 0x0
#define BAGDE_ALLOW_TO_DISPLAY 0x1

typedef struct {
	uid_t uid;
	sqlite3 *db;
} badge_setting_info;

static bool _get_table_field_data_int(char **table, int *buf, int index)
{
	if (table == NULL || buf == NULL || index < 0) {
		/* LCOV_EXCL_START */
		ERR("table[%p], buf[%p], index[%d]", table, buf, index);
		return false;
		/* LCOV_EXCL_STOP */
	}

	if (table[index] != NULL) {
		*buf = atoi(table[index]);
		return true;
	}

	/* LCOV_EXCL_START */
	*buf = 0;
	return false;
	/* LCOV_EXCL_STOP */
}

static bool _get_table_field_data_string(char **table, char **buf, int ucs2, int index)
{
	bool ret = false;
	int sLen = 0;
	char *pTemp;

	if (table == NULL || buf == NULL || index < 0) {
		/* LCOV_EXCL_START */
		ERR("table[%p], buf[%p], index[%d]", table, buf, index);
		return false;
		/* LCOV_EXCL_STOP */
	}

	pTemp = table[index];
	if (pTemp == NULL) {
		*buf = NULL; /* LCOV_EXCL_LINE */
	} else {
		sLen = strlen(pTemp);
		if (sLen) {
			*buf = (char *)malloc(sLen + 1);
			if (*buf == NULL) {
				ERR("malloc is failed"); /* LCOV_EXCL_LINE */
				goto out;
			}
			memset(*buf, 0, sLen + 1);
			strncpy(*buf, pTemp, sLen);
		} else {
			*buf = NULL; /* LCOV_EXCL_LINE */
		}
	}

	ret = true;

out:
	return ret;
}

EXPORT_API int badge_db_get_setting_by_appid(const char *appid, badge_setting_h *setting, uid_t uid)
{
	int ret = BADGE_ERROR_NONE;
	int sql_ret;
	int row_count;
	int col_count;
	int col_index;
	char *sql_query = NULL;
	char **query_result = NULL;
	badge_setting_h result_setting;
	sqlite3 *db = NULL;
	int atd;

	if (appid == NULL)
		return BADGE_ERROR_INVALID_PARAMETER;

	sql_ret = db_util_open(BADGE_DB_PATH, &db, 0);
	if (sql_ret != SQLITE_OK || db == NULL) {
		/* LCOV_EXCL_START */
		ERR("Failed db util open [%s][%d]", BADGE_DB_PATH, sql_ret);
		return BADGE_ERROR_FROM_DB;
		/* LCOV_EXCL_STOP */
	}

	sql_query = sqlite3_mprintf("SELECT pkgname, appid, allow_to_display FROM %s " \
				"WHERE appid = %Q AND (uid = %d OR uid = %d) " \
				"ORDER BY uid DESC;",
				BADGE_SETTING_DB_TABLE, appid, uid, tzplatform_getuid(TZ_SYS_GLOBALAPP_USER));
	if (!sql_query) {
		/* LCOV_EXCL_START */
		ERR("Failed to alloc query");
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	sql_ret = sqlite3_get_table(db, sql_query, &query_result, &row_count, &col_count, NULL);
	if (sql_ret != SQLITE_OK && sql_ret != -1) {
		/* LCOV_EXCL_START */
		ERR("sqlite3_get_table failed [%d][%s]", sql_ret,
					sqlite3_errmsg(db));
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	if (!row_count) {
		/* LCOV_EXCL_START */
		DBG("No setting found for [%s]", appid);
		ret = BADGE_ERROR_NOT_EXIST;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	result_setting = (struct badge_setting *)malloc(sizeof(struct badge_setting));
	if (result_setting == NULL) {
		/* LCOV_EXCL_START */
		ERR("Failed to alloc setting");
		ret = BADGE_ERROR_OUT_OF_MEMORY;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	col_index = col_count;

	_get_table_field_data_string(query_result, &(result_setting[0].pkgname), 1, col_index++);
	_get_table_field_data_string(query_result, &(result_setting[0].appid), 1, col_index++);
	if (_get_table_field_data_int(query_result, &atd, col_index++)) {
		if (atd & BAGDE_APP_DISABLE_BIT)
			result_setting[0].allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY;
		else if (atd & BAGDE_ALLOW_TO_DISPLAY_BIT)
			result_setting[0].allow_to_display = BAGDE_ALLOW_TO_DISPLAY;
		else
			result_setting[0].allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY;
	} else {
		result_setting[0].allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY;
	}

	*setting = result_setting;

out:
	if (query_result)
		sqlite3_free_table(query_result);
	if (sql_query)
		sqlite3_free(sql_query);
	if (db) {
		sql_ret = db_util_close(db);
		if (sql_ret != SQLITE_OK)
			WARN("Failed to db_util_close");
	}

	return ret;
}

EXPORT_API int badge_db_update_setting(char *pkgname, char *appid, int allow_to_display, uid_t uid)
{
	int ret = BADGE_ERROR_NONE;
	sqlite3 *db = NULL;
	char *sqlbuf = NULL;
	int sql_ret;

	if (pkgname == NULL || appid == NULL) {
		ERR("Invalid package name or app id");
		return BADGE_ERROR_INVALID_PARAMETER;
	}

	sql_ret = db_util_open(BADGE_DB_PATH, &db, 0);
	if (sql_ret != SQLITE_OK || db == NULL) {
		/* LCOV_EXCL_START */
		ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sql_ret);
		return BADGE_ERROR_FROM_DB;
		/* LCOV_EXCL_STOP */
	}

	/* Only the first bit is updated.
		(The first bit indicates allow information, and the second bit indicates app disable information.)
	*/
	sqlbuf = sqlite3_mprintf("UPDATE %s SET allow_to_display = (allow_to_display & ~%d ) | %d " \
				"WHERE pkgname = %Q AND appid = %Q " \
				"AND uid = %d;",
				BADGE_SETTING_DB_TABLE, BAGDE_ALLOW_TO_DISPLAY_BIT, allow_to_display,
				pkgname, appid, uid);

	if (!sqlbuf) {
		/* LCOV_EXCL_START */
		ERR("Failed to alloc query");
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	ret = badge_db_exec(db, sqlbuf, NULL);

out:
	if (sqlbuf)
		sqlite3_free(sqlbuf);
	if (db) {
		sql_ret = db_util_close(db);
		if (sql_ret != SQLITE_OK)
			WARN("Failed to db_util_close");
	}

	return ret;
}

EXPORT_API int badge_db_get_allow_to_display_by_appid(char *appid, int *allow_to_display, uid_t uid)
{
	int ret = BADGE_ERROR_NONE;
	int sql_ret;
	int row_count;
	int col_count;
	int col_index;
	char *sql_query = NULL;
	char **query_result = NULL;
	sqlite3 *db = NULL;
	int atd;

	if (appid == NULL)
		return BADGE_ERROR_INVALID_PARAMETER;

	sql_ret = db_util_open(BADGE_DB_PATH, &db, 0);
	if (sql_ret != SQLITE_OK || db == NULL) {
		/* LCOV_EXCL_START */
		ERR("Failed db util open [%s][%d]", BADGE_DB_PATH, sql_ret);
		return BADGE_ERROR_FROM_DB;
		/* LCOV_EXCL_STOP */
	}

	sql_query = sqlite3_mprintf("SELECT allow_to_display FROM %s WHERE appid = %Q " \
				"AND (uid = %d OR uid = %d) ORDER BY uid DESC;",
				BADGE_SETTING_DB_TABLE, appid, uid,
				tzplatform_getuid(TZ_SYS_GLOBALAPP_USER));
	if (!sql_query) {
		/* LCOV_EXCL_START */
		ERR("Failed to alloc query");
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	sql_ret = sqlite3_get_table(db, sql_query, &query_result, &row_count, &col_count, NULL);
	if (sql_ret != SQLITE_OK && sql_ret != -1) {
		/* LCOV_EXCL_START */
		ERR("sqlite3_get_table failed [%d][%s]", sql_ret,
					sqlite3_errmsg(db));
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	if (!row_count) {
		/* LCOV_EXCL_START */
		DBG("No setting found for [%s]", appid);
		ret = BADGE_ERROR_NOT_EXIST;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	col_index = col_count;

	if (_get_table_field_data_int(query_result, &atd, col_index++)) {
		if (atd & BAGDE_APP_DISABLE_BIT)
			*allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY;
		else if (atd & BAGDE_ALLOW_TO_DISPLAY_BIT)
			*allow_to_display = BAGDE_ALLOW_TO_DISPLAY;
		else
			*allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY;
	} else {
		*allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY;
	}

out:
	if (query_result)
		sqlite3_free_table(query_result);
	if (sql_query)
		sqlite3_free(sql_query);
	if (db) {
		sql_ret = db_util_close(db);
		if (sql_ret != SQLITE_OK)
			WARN("Failed to db_util_close");
	}

	return ret;
}

EXPORT_API int badge_db_update_app_disabled(const char *app_id, bool disabled, uid_t uid)
{
	int ret = BADGE_ERROR_NONE;
	sqlite3 *db = NULL;
	char *sqlbuf = NULL;
	int sql_ret;
	int num_changes = 0;
	int flag;

	if (app_id == NULL) {
		ERR("Invalid app id");
		return BADGE_ERROR_INVALID_PARAMETER;
	}

	sql_ret = db_util_open(BADGE_DB_PATH, &db, 0);
	if (sql_ret != SQLITE_OK || db == NULL) {
		/* LCOV_EXCL_START */
		ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sql_ret);
		return BADGE_ERROR_FROM_DB;
		/* LCOV_EXCL_STOP */
	}

	if (disabled)
		flag = BAGDE_APP_DISABLE;
	else
		flag = BAGDE_APP_ENABLE;

	/* Only the second bit is updated.
		(The first bit indicates allow information, and the second bit indicates app disable information.)
	*/
	sqlbuf = sqlite3_mprintf("UPDATE %s SET allow_to_display = (allow_to_display & ~%d ) | %d " \
				"WHERE appid = %Q " \
				"AND uid = %d;",
				BADGE_SETTING_DB_TABLE, BAGDE_APP_DISABLE_BIT, flag, app_id, uid);
	if (!sqlbuf) {
		/* LCOV_EXCL_START */
		ERR("Failed to alloc query");
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	ret = badge_db_exec(db, sqlbuf, &num_changes);
	if (ret == BADGE_ERROR_NONE && num_changes <= 0)
		ret = BADGE_ERROR_NOT_EXIST;

out:
	if (sqlbuf)
		sqlite3_free(sqlbuf);
	if (db) {
		sql_ret = db_util_close(db);
		if (sql_ret != SQLITE_OK)
			WARN("Failed to db_util_close");
	}

	return ret;
}

EXPORT_API int badge_db_update_pkg_disabled(const char *pkg_id, bool disabled, uid_t uid)
{
	int ret = BADGE_ERROR_NONE;
	sqlite3 *db = NULL;
	char *sqlbuf = NULL;
	int sql_ret;
	int num_changes = 0;
	int flag;

	if (pkg_id == NULL) {
		ERR("Invalid pkg id");
		return BADGE_ERROR_INVALID_PARAMETER;
	}

	sql_ret = db_util_open(BADGE_DB_PATH, &db, 0);
	if (sql_ret != SQLITE_OK || db == NULL) {
		/* LCOV_EXCL_START */
		ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sql_ret);
		return BADGE_ERROR_FROM_DB;
		/* LCOV_EXCL_STOP */
	}

	if (disabled)
		flag = BAGDE_APP_DISABLE;
	else
		flag = BAGDE_APP_ENABLE;

	/* Only the second bit is updated.
		(The first bit indicates allow information, and the second bit indicates app disable information.)
	*/
	sqlbuf = sqlite3_mprintf("UPDATE %s SET allow_to_display = (allow_to_display & ~%d ) | %d " \
				"WHERE pkgname = %Q AND uid = %d;",
				BADGE_SETTING_DB_TABLE, BAGDE_APP_DISABLE_BIT, flag, pkg_id, uid);
	if (!sqlbuf) {
		/* LCOV_EXCL_START */
		ERR("Failed to alloc query");
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	ret = badge_db_exec(db, sqlbuf, &num_changes);
	if (ret == BADGE_ERROR_NONE && num_changes <= 0)
		ret = BADGE_ERROR_NOT_EXIST;

out:
	if (sqlbuf)
		sqlite3_free(sqlbuf);
	if (db) {
		sql_ret = db_util_close(db);
		if (sql_ret != SQLITE_OK)
			WARN("Failed to db_util_close");
	}

	return ret;
}

EXPORT_API int badge_setting_is_existed_appid(const char *appid, bool *is_existed, uid_t uid)
{
	int ret = BADGE_ERROR_NONE;
	int sqlret;
	sqlite3 *db = NULL;
	sqlite3_stmt *stmt = NULL;
	char *sqlbuf = NULL;
	int count = 0;

	if (appid == NULL || is_existed == NULL) {
		ERR("Invalid parameter");
		return BADGE_ERROR_INVALID_PARAMETER;
	}

	sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
	if (sqlret != SQLITE_OK || !db) {
		/* LCOV_EXCL_START */
		ERR("Failed to db_util_open [%d]", sqlret);
		if (sqlret == SQLITE_PERM)
			return BADGE_ERROR_PERMISSION_DENIED;
		return BADGE_ERROR_FROM_DB;
		/* LCOV_EXCL_STOP */
	}

	sqlbuf = sqlite3_mprintf("SELECT count(*) FROM %q WHERE " \
				"appid = %Q AND uid = %d",
				BADGE_SETTING_DB_TABLE, appid, uid);
	if (!sqlbuf) {
		/* LCOV_EXCL_START */
		ERR("Failed to alloc query");
		ret = BADGE_ERROR_OUT_OF_MEMORY;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
	if (sqlret != SQLITE_OK) {
		/* LCOV_EXCL_START */
		ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlret,
					sqlite3_errmsg(db));
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	sqlret = sqlite3_step(stmt);
	if (sqlret == SQLITE_ROW)
		count = sqlite3_column_int(stmt, 0);

	if (count > 0)
		*is_existed = true;
	else
		*is_existed = false;

out:
	if (sqlbuf)
		sqlite3_free(sqlbuf);
	if (stmt)
		sqlite3_finalize(stmt);
	if (db) {
		sqlret = db_util_close(db);
		if (sqlret != SQLITE_OK)
			WARN("Failed to db_util_close [%d]", sqlret);
	}

	return ret;
}

static bool _is_package_in_setting_table(sqlite3 *db, const char *pkgname, const char* appid, uid_t uid)
{
	int sql_ret;
	bool err = true;
	char *query = NULL;
	sqlite3_stmt *stmt = NULL;

	if (appid != NULL)
		query = sqlite3_mprintf("SELECT appid FROM badge_setting " \
				"WHERE uid = %d AND pkgname = %Q AND appid = %Q",
				uid, pkgname, appid);
	else
		query = sqlite3_mprintf("SELECT pkgname FROM badge_setting " \
				"WHERE uid = %d AND pkgname = %Q",
				uid, pkgname);
	if (query == NULL) {
		/* LCOV_EXCL_START */
		ERR("Out of Memory");
		err = false;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	sql_ret = sqlite3_prepare_v2(db, query, -1, &stmt, NULL);
	if (sql_ret != SQLITE_OK) {
		ERR("sqlite3_prepare_v2 failed [%d][%s]", sql_ret, sqlite3_errmsg(db));
		err = false;
		goto out;
	}

	sql_ret = sqlite3_step(stmt);
	if (sql_ret == SQLITE_DONE) {
		INFO("No matched appid[%s] from pkgname[%s]", pkgname, appid);
		err = false;
		goto out;
	}

	if (sql_ret != SQLITE_OK && sql_ret != SQLITE_ROW) {
		/* LCOV_EXCL_START */
		ERR("sqlite3_step failed [%d][%s]", sql_ret,
				sqlite3_errmsg(db));
		err = false;
		goto out;
		/* LCOV_EXCL_STOP */
	}

out:
	if (stmt)
		sqlite3_finalize(stmt);
	if (query)
		sqlite3_free(query);

	return err;
}

static int app_info_callback(const pkgmgrinfo_appinfo_h handle, void *user_data)
{
	int ret;
	int pkgmgr_ret;
	char *appid = NULL;
	char *pkgname = NULL;
	char *query = NULL;
	badge_setting_info *info = (badge_setting_info *)user_data;
	sqlite3 *db = info->db;

	pkgmgr_ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
	if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE) {
		ERR("pkgmgrinfo_appinfo_get_appid failed [%d]", pkgmgr_ret);
		goto out;
	}

	pkgmgr_ret = pkgmgrinfo_appinfo_get_pkgname(handle, &pkgname);
	if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE) {
		ERR("pkgmgrinfo_appinfo_get_pkgname failed [%d]", pkgmgr_ret);
		goto out;
	}

	if (_is_package_in_setting_table(db, pkgname, appid, info->uid) == true) {
		INFO("uid[%d] appid[%s] is exist", info->uid, appid);
		goto out;
	}

	query = sqlite3_mprintf("INSERT INTO badge_setting " \
				"(uid, pkgname, appid) VALUES (%d, %Q, %Q) ",
				info->uid, pkgname, appid);
	if (query == NULL) {
		ERR("Out of memory");
		goto out;
	}

	ret = badge_db_exec(db, query, NULL);
	if (ret != BADGE_ERROR_NONE) {
		ERR("DB Error");
		goto out;
	}

	INFO("Insert uid[%d] pkgname[%s] appid[%s]", info->uid, pkgname, appid);

out:
	if (query)
		sqlite3_free(query);

	return 0;
}

static int package_info_callback(const pkgmgrinfo_pkginfo_h package_info, void *user_data)
{
	char *pkgname = NULL;
	int pkgmgr_ret = PACKAGE_MANAGER_ERROR_NONE;
	pkgmgrinfo_appinfo_filter_h handle = NULL;
	badge_setting_info *info = (badge_setting_info *)user_data;

	pkgmgr_ret = pkgmgrinfo_pkginfo_get_pkgname(package_info, &pkgname);
	if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE) {
		ERR("package_info_get_package failed [%d]", pkgmgr_ret);
		goto out;
	}

	pkgmgr_ret = pkgmgrinfo_appinfo_filter_create(&handle);
	if (pkgmgr_ret != PMINFO_R_OK) {
		/* LCOV_EXCL_START */
		ERR("pkgmgrinfo_appinfo_filter_create failed [%d]", pkgmgr_ret);
		goto out;
		/* LCOV_EXCL_STOP */
	}

	pkgmgr_ret = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_PACKAGE, pkgname);
	if (pkgmgr_ret != PMINFO_R_OK) {
		/* LCOV_EXCL_START */
		ERR("pkgmgrinfo_appinfo_filter_add_string failed [%d]",
					pkgmgr_ret);
		goto out;
		/* LCOV_EXCL_STOP */
	}

	pkgmgr_ret = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_NODISPLAY, false);
	if (pkgmgr_ret != PMINFO_R_OK) {
		/* LCOV_EXCL_START */
		ERR("pkgmgrinfo_appinfo_filter_add_bool failed [%d]",
					pkgmgr_ret);
		goto out;
		/* LCOV_EXCL_STOP */
	}

	pkgmgr_ret = pkgmgrinfo_appinfo_usr_filter_foreach_appinfo(handle, app_info_callback, info, info->uid);
	if (pkgmgr_ret != PMINFO_R_OK) {
		/* LCOV_EXCL_START */
		ERR("pkgmgrinfo_pkginfo_filter_foreach_appinfo failed [%d]",
					pkgmgr_ret);
		goto out;
		/* LCOV_EXCL_STOP */
	}

out:
	if (handle)
		pkgmgrinfo_appinfo_filter_destroy(handle);

	return 0;
}

EXPORT_API int badge_setting_insert_package_for_uid(const char *pkgname, uid_t uid)
{
	sqlite3 *db;
	int ret = BADGE_ERROR_NONE;
	int sqlite3_ret = SQLITE_OK;
	int pkgmgr_ret = PACKAGE_MANAGER_ERROR_NONE;
	badge_setting_info info;
	pkgmgrinfo_pkginfo_filter_h handle = NULL;

	sqlite3_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, SQLITE_OPEN_READWRITE, NULL);
	if (sqlite3_ret != SQLITE_OK || db == NULL) {
		ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sqlite3_ret);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
	}

	sqlite3_exec(db, "BEGIN immediate;", NULL, NULL, NULL);

	pkgmgr_ret = pkgmgrinfo_pkginfo_filter_create(&handle);
	if (pkgmgr_ret != PMINFO_R_OK) {
		/* LCOV_EXCL_START */
		ERR("pkgmgrinfo_pkginfo_filter_create failed [%d]", pkgmgr_ret);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	pkgmgr_ret = pkgmgrinfo_pkginfo_filter_add_string(handle,
			PMINFO_PKGINFO_PROP_PACKAGE_PRIVILEGE, BADGE_PRIVILEGE);
	if (pkgmgr_ret != PMINFO_R_OK) {
		/* LCOV_EXCL_START */
		ERR("Failed to add string to pkginfo_filter[%d]", pkgmgr_ret);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	pkgmgr_ret = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgname);
	if (pkgmgr_ret != PMINFO_R_OK) {
		/* LCOV_EXCL_START */
		ERR("pkgmgrinfo_pkginfo_filter_add_string failed [%d]",
					pkgmgr_ret);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	info.db = db;
	info.uid = uid;
	pkgmgr_ret = pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, package_info_callback, &info, uid);
	if (pkgmgr_ret != PMINFO_R_OK) {
		/* LCOV_EXCL_START */
		ERR("pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo failed [%d]",
					pkgmgr_ret);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

out:
	if (handle)
		pkgmgrinfo_pkginfo_filter_destroy(handle);
	if (db) {
		if (ret == BADGE_ERROR_NONE)
			sqlite3_exec(db, "END;", NULL, NULL, NULL);
		else
			sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL);

		if ((sqlite3_ret = db_util_close(db)) != SQLITE_OK)
			WARN("db_util_close failed [%d]", sqlite3_ret);
	}

	return ret;
}

EXPORT_API int badge_setting_delete_package_for_uid(const char *pkgname, uid_t uid)
{
	int ret = BADGE_ERROR_NONE;
	int sql_ret;
	sqlite3 *db = NULL;
	bool is_package_in_setting_table = false;
	char *query = NULL;

	sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, SQLITE_OPEN_READWRITE, NULL);
	if (ret != SQLITE_OK || db == NULL) {
		/* LCOV_EXCL_START */
		ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sql_ret);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	is_package_in_setting_table = _is_package_in_setting_table(db, pkgname, NULL, uid);
	if (is_package_in_setting_table == false) {
		INFO("[%s] is not exist", pkgname);
		goto out;
	}

	sqlite3_exec(db, "BEGIN immediate;", NULL, NULL, NULL);

	query = sqlite3_mprintf("DELETE FROM badge_setting " \
				"WHERE uid = %d AND pkgname = %Q ",
				uid, pkgname);
	if (query == NULL) {
		/* LCOV_EXCL_START */
		ERR("Out of memory");
		ret = BADGE_ERROR_OUT_OF_MEMORY;
		goto out;
		/* LCOV_EXCL_STOP */
	}

	ret = badge_db_exec(db, query, NULL);
	if (ret != BADGE_ERROR_NONE) {
		/* LCOV_EXCL_START */
		ERR("DB Error");
		goto out;
		/* LCOV_EXCL_STOP */
	}

out:
	if (query)
		sqlite3_free(query);
	if (db) {
		if (ret == BADGE_ERROR_NONE)
			sqlite3_exec(db, "END;", NULL, NULL, NULL);
		else
			sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL);

		if ((sql_ret = db_util_close(db)) != SQLITE_OK)
			WARN("db_util_close failed [%d]", sql_ret);
	}

	return ret;
}

/* LCOV_EXCL_START */
EXPORT_API int badge_setting_refresh_setting_table(uid_t uid)
{
	int ret = BADGE_ERROR_NONE;
	int sql_ret;
	int pkgmgr_ret;
	sqlite3 *db = NULL;
	badge_setting_info info;
	pkgmgrinfo_appinfo_filter_h filter = NULL;

	sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, SQLITE_OPEN_READWRITE, NULL);
	if (sql_ret != SQLITE_OK || db == NULL) {
		ERR("sqlite3_open_v2 fail [%s][%d]", BADGE_DB_PATH, sql_ret);
		return BADGE_ERROR_FROM_DB;
	}

	sqlite3_exec(db, "BEGIN immediate;", NULL, NULL, NULL);

	pkgmgr_ret = pkgmgrinfo_appinfo_filter_create(&filter);
	if (pkgmgr_ret != PMINFO_R_OK) {
		ERR("pkgmgrinfo_appinfo_filter_create failed [%d]", pkgmgr_ret);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
	}

	pkgmgr_ret = pkgmgrinfo_appinfo_filter_add_string(filter,
			PMINFO_APPINFO_PROP_PRIVILEGE, BADGE_PRIVILEGE);
	if (pkgmgr_ret != PMINFO_R_OK) {
		ERR("pkgmgrinfo_appinfo_filter_add_string failed [%d]",
					pkgmgr_ret);
		goto out;
	}

	pkgmgr_ret = pkgmgrinfo_appinfo_filter_add_bool(filter,
			PMINFO_APPINFO_PROP_APP_NODISPLAY, false);
	if (pkgmgr_ret != PMINFO_R_OK) {
		ERR("pkgmgrinfo_appinfo_filter_add_bool failed [%d]",
					pkgmgr_ret);
		goto out;
	}

	info.db = db;
	info.uid = uid;
	pkgmgr_ret = pkgmgrinfo_appinfo_usr_filter_foreach_appinfo(filter,
			app_info_callback, &info, uid);
	if (pkgmgr_ret != PMINFO_R_OK) {
		ERR("pkgmgrinfo_appinfo_usr_filter_foreach_appinfo failed [%d]",
					pkgmgr_ret);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
	}

out:
	if (filter)
		pkgmgrinfo_appinfo_filter_destroy(filter);
	if (db) {
		if (ret == BADGE_ERROR_NONE)
			sqlite3_exec(db, "END;", NULL, NULL, NULL);
		else
			sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL);
		if ((sql_ret = db_util_close(db)) != SQLITE_OK)
			WARN("fail to db_util_close [%d]", sql_ret);
	}

	return ret;
}
/* LCOV_EXCL_STOP */

/* LCOV_EXCL_START */
EXPORT_API int badge_setting_arrange_tables(uid_t uid)
{
	int ret = BADGE_ERROR_NONE;
	int sqlret;
	sqlite3 *db = NULL;
	char *sqlbuf = NULL;

	sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
	if (sqlret != SQLITE_OK || !db) {
		ERR("Failed to db_util_open [%d]", sqlret);
		if (sqlret == SQLITE_PERM)
			return BADGE_ERROR_PERMISSION_DENIED;
		return BADGE_ERROR_FROM_DB;
	}

	sqlbuf = sqlite3_mprintf("DELETE FROM %Q WHERE pkgname not in " \
				"(SELECT pkgname FROM %Q) AND uid = %d",
				BADGE_TABLE_NAME, BADGE_SETTING_DB_TABLE, uid);
	if (sqlbuf == NULL) {
		ERR("Failed to alloc query");
		ret = BADGE_ERROR_OUT_OF_MEMORY;
		goto out;
	}

	ret = badge_db_exec(db, sqlbuf, NULL);
	if (ret != BADGE_ERROR_NONE)
		goto out;

	if (sqlbuf) {
		sqlite3_free(sqlbuf);
		sqlbuf = NULL;
	}

	sqlbuf = sqlite3_mprintf("DELETE FROM %Q WHERE pkgname not in " \
				"(SELECT pkgname FROM %Q) AND uid = %d",
				BADGE_OPTION_TABLE_NAME, BADGE_SETTING_DB_TABLE,
				uid);
	if (sqlbuf == NULL) {
		ERR("Failed to alloc query");
		ret = BADGE_ERROR_OUT_OF_MEMORY;
		goto out;
	}

	ret = badge_db_exec(db, sqlbuf, NULL);

out:
	if (sqlbuf)
		sqlite3_free(sqlbuf);

	if (db) {
		sqlret = db_util_close(db);
		if (sqlret != SQLITE_OK)
			WARN("Failed to db_util_close [%d]", sqlret);
	}

	return ret;
}
/* LCOV_EXCL_STOP */