/*
 * Copyright 2012  Samsung Electronics Co., Ltd
 *
 * Licensed under the Flora License, Version 1.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.tizenopensource.org/license
 *
 * 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 <regex.h>
#include <errno.h>
#include <aul.h>
#include <ui-gadget-module.h>
#include <vconf.h>
#include <vconf-keys.h>
#include <fcntl.h>
#include <app_service.h>

#include "phone.h"
#include "ct-list.h"
#include "ct-detail.h"
#include "ct-detail-utils.h"
#include "ct-input-utils.h"
#include "ct-input-view.h"

static void input_change_photo(ct_input_data *cinput_d, const char *normal,
		const char *full)
{
	int ret;
	CTSvalue* base_info = NULL;

	base_info = ct_detail_get_baseinfo_value(cinput_d->contact);

	ret = contacts_svc_value_set_str(base_info, CTS_BASE_VAL_IMG_PATH_STR, normal);
	p_warn_if(CTS_SUCCESS != ret, "contacts_svc_value_set_str() failed(%d)", ret);

	ret = contacts_svc_value_set_str(base_info, CTS_BASE_VAL_FULL_IMG_PATH_STR, full);
	p_warn_if(CTS_SUCCESS != ret, "contacts_svc_value_set_str() failed(%d)", ret);

	ct_input_update_image(cinput_d);
}

static void input_img_crop_result(ui_gadget_h ug, service_h service, void *data)
{
	char *normal = NULL;
	char *full = NULL;
	ct_input_data *cinput_d = data;

	p_retm_if(NULL == ug || NULL == data, "ug or data is NULL");

	if (service) {
		service_get_extra_data(service, "crop_image_path", &normal);
		p_retm_if(!normal, "return value is NULL.\n");

		service_get_extra_data(service, "image_path", &full);
		input_change_photo(cinput_d, normal, full);
		free(normal);
	}
	ug_destroy(ug);
	cinput_d->crop_ug = NULL;

	if (cinput_d->src_ug) {
		ug_destroy(cinput_d->src_ug);
		cinput_d->src_ug = NULL;
	}
}

static void input_src_ug_destroy(ui_gadget_h ug, void *priv)
{
	ct_input_data *cinput_d = priv;
	p_retm_if(NULL == ug, "ug is NULL");

	elm_object_tree_focus_allow_set(cinput_d->cdetail_d->navi, EINA_TRUE);

	if (NULL == cinput_d->crop_ug) {
		ug_destroy(ug);
		cinput_d->src_ug = NULL;
	}
}

static void input_crop_ug_destroy(ui_gadget_h ug, void *priv)
{
	ct_input_data *cinput_d = priv;
	p_retm_if(NULL == ug, "ug is NULL");

	if (cinput_d->crop_ug) {
		ug_destroy(ug);
		cinput_d->crop_ug = NULL;
	}
}

static void input_gallery_result(ui_gadget_h ug, service_h service, void *data)
{
	char *val = NULL;
	ct_input_data *cinput_d = data;

	p_retm_if(NULL == ug || NULL == data, "ug or data is NULL");

	if (service) {
		struct ug_cbs cbs = {0};

		service_get_extra_data(service, "path", &val);
		p_retm_if(!val, "return value is NULL.\n");

		cbs.result_cb = input_img_crop_result;
		cbs.destroy_cb = input_crop_ug_destroy;
		cbs.priv = cinput_d;
		cinput_d->crop_ug = phone_image_crop_ug(cinput_d->cdetail_d->ug, val, &cbs);
		free(val);
	}
}

void ct_input_gallery(void *data, Evas_Object *obj, void *event_info)
{
	struct ug_cbs cbs = {0};
	ct_input_data *cinput_d = data;

	service_h service;

	service_create(&service);
	service_add_extra_data(service, "launch-type", "select-one");
	service_add_extra_data(service, "file-type", "image");

	cbs.result_cb = input_gallery_result;
	cbs.destroy_cb = input_src_ug_destroy;
	cbs.layout_cb = ug_common_layout_cb;
	cbs.priv = cinput_d;

	cinput_d->src_ug = ug_create(cinput_d->cdetail_d->ug, GALLERY_UG, UG_MODE_FULLVIEW, service, &cbs);
	p_warn_if(NULL == cinput_d->src_ug, "ug_create() Failed");

	service_destroy(service);
	evas_object_del(cinput_d->cdetail_d->popup);
	cinput_d->cdetail_d->popup = NULL;
}

static void input_camera_result(service_h service, service_h reply, service_result_e result, void* user_data)
{
	char *normal = NULL;
	char *full = NULL;
	ct_input_data *cinput_d = user_data;

	service_get_extra_data(reply, "crop_image_path", &normal);
	p_retm_if(!normal, "return value is NULL.\n");

	service_get_extra_data(reply, "image_path", &full);
	input_change_photo(cinput_d, normal, full);

	free(normal);
	free(full);
}

void ct_input_camera(void *data, Evas_Object *obj, void *event_info)
{
	int ret;
	ct_input_data *cinput_d = data;
	service_h service;

	p_retm_if(NULL == cinput_d, "paramter(ct_input_data) is NULL");

	if (cinput_d->cdetail_d && cinput_d->cdetail_d->popup)
		ct_detail_popup_hide_cb(cinput_d->cdetail_d, NULL, NULL);

	service = NULL;
	ret = service_create(&service);
	p_retm_if(SERVICE_ERROR_NONE != ret, "service_create() Failed(%d)", ret);

	ret = service_set_operation(service, SERVICE_OPERATION_CREATE_CONTENT);
	if (SERVICE_ERROR_NONE != ret) {
		ERR("service_set_operation() Failed(%d)", ret);
		ret = service_destroy(service);
		p_warn_if(SERVICE_ERROR_NONE != ret, "service_destroy() Failed(%d)", ret);
		return;
	}

	ret = service_set_mime(service, "image/jpg");
	if (SERVICE_ERROR_NONE != ret) {
		ERR("service_set_mime() Failed(%d)", ret);
		ret = service_destroy(service);
		p_warn_if(SERVICE_ERROR_NONE != ret, "service_destroy() Failed(%d)", ret);
		return;
	}

	ret = service_set_package(service, CAMERA_PKG);
	if (SERVICE_ERROR_NONE != ret) {
		ERR("service_set_package() Failed(%d)", ret);
		ret = service_destroy(service);
		p_warn_if(SERVICE_ERROR_NONE != ret, "service_destroy() Failed(%d)", ret);
		return;
	}

	ret = service_add_extra_data(service, "CALLER", "contacts");
	if (SERVICE_ERROR_NONE != ret) {
		ERR("service_add_extra_data() Failed(%d)", ret);
		ret = service_destroy(service);
		p_warn_if(SERVICE_ERROR_NONE != ret, "service_destroy() Failed(%d)", ret);
		return;
	}

	ret = service_send_launch_request(service, input_camera_result, data);
	if (SERVICE_ERROR_NONE != ret) {
		ERR("service_send_launch_request() Failed(%d)", ret);
		ret = service_destroy(service);
		p_warn_if(SERVICE_ERROR_NONE != ret, "service_destroy() Failed(%d)", ret);
		return;
	}

	ret = service_destroy(service);
	p_retm_if(SERVICE_ERROR_NONE != ret, "service_destroy() Failed(%d)", ret);
}

static void input_myfile_ringtone_result(ui_gadget_h ug, service_h service, void *data)
{
	ct_input_data *cinput_d = data;

	p_retm_if(NULL == ug || NULL == data, "ug or data is NULL");

	if (service) {
		const char* display;
		CTSvalue *base_info = NULL;
		CTSstruct *contact = cinput_d->contact;

		char *val = NULL;
		service_get_extra_data(service, "result", &val);
		p_retm_if(!val, "return value is NULL.\n");

		contacts_svc_struct_get_value(contact, CTS_CF_BASE_INFO_VALUE, &base_info);
		if (NULL == base_info) {
			base_info = contacts_svc_value_new(CTS_VALUE_CONTACT_BASE_INFO);
			contacts_svc_struct_store_value(contact, CTS_CF_BASE_INFO_VALUE, base_info);
		}
		contacts_svc_value_set_str(base_info, CTS_BASE_VAL_RINGTONE_PATH_STR, val);
		display = ct_detail_get_ringtone_display_name(val);
		free(val);

		ct_input_update_ringtone(contact, cinput_d->ly_ringtone);
	}

	ug_destroy(ug);
	cinput_d->src_ug = NULL;
}

static inline ui_gadget_h input_myfile_ug(struct ug_cbs cbs,
		service_h service, ct_input_data *cinput_d)
{
	ui_gadget_h ug;

	cbs.layout_cb = ug_common_layout_cb;
	cbs.priv = cinput_d;

	ug = ug_create(cinput_d->cdetail_d->ug, MYFILES_UG, UG_MODE_FULLVIEW, service, &cbs);
	p_warn_if(NULL == ug, "ug_create() Failed");

	return ug;
}

void ct_input_myfile_ringtone(ct_input_data *cinput_d)
{
	struct ug_cbs cbs = {0};

	service_h service;

	service_create(&service);

	service_add_extra_data(service, "path", "/opt/share/settings/Ringtones");
	service_add_extra_data(service, "select_type", "SINGLE_FILE");
	service_add_extra_data(service, "file_type", "SOUND");

	cbs.result_cb = input_myfile_ringtone_result;
	cbs.destroy_cb = input_src_ug_destroy;
	cinput_d->src_ug = input_myfile_ug(cbs, service, cinput_d);

	service_destroy(service);
}

#define ACCOUNT_RGEX		"([a-z0-9!#$%&'*+/=?^_`{|}~-]+[.])*[a-z0-9!#$%&'*+/=?^_`{|}~-]+"
#define DOMAIN_RGEX		"([a-z0-9!#$%&'*+/=?^_`{|}~-]+[.])+[a-z0-9!#$%&'*+/=?^_`{|}~-]+"
#define EMAIL_RGEX		ACCOUNT_RGEX"@"DOMAIN_RGEX

int ct_input_valid_email(CTSstruct *contact)
{
	int result = TRUE;
	GSList *list = NULL;
	GSList *cursor;

	contacts_svc_struct_get_list(contact, CTS_CF_EMAIL_LIST, &list);

	for (cursor=list;cursor;cursor=cursor->next) {
		const char *email = NULL;

		if (contacts_svc_value_get_bool(cursor->data, CTS_EMAIL_VAL_DELETE_BOOL))
			continue;

		email = contacts_svc_value_get_str(cursor->data, CTS_EMAIL_VAL_ADDR_STR);
		if (email && *email) {
			int len = strlen(email) + 1;
			regex_t compiled;
			regmatch_t str[len];

			if (regcomp(&compiled, EMAIL_RGEX, REG_ICASE | REG_EXTENDED))
				result = FALSE;
			if (regexec(&compiled, email, len, str, 0) == REG_NOMATCH)
				result = FALSE;

			regfree(&compiled);
		}
		if (!result)
			break;
	}
	return result;
}

static int input_is_name_empty(CTSstruct *contact)
{
	int ret;
	CTSvalue *name_val;
	const char *name = NULL;

	ret = contacts_svc_struct_get_value(contact, CTS_CF_NAME_VALUE, &name_val);

	p_retv_if(CTS_ERR_NO_DATA == ret, TRUE);
	p_retvm_if(CTS_SUCCESS != ret, TRUE, "contacts_svc_struct_get_value() Failed(%d)", ret);

	name = contacts_svc_value_get_str(name_val, CTS_NAME_VAL_FIRST_STR);
	if (NULL == name || '\0' == *name) {
		name = contacts_svc_value_get_str(name_val, CTS_NAME_VAL_LAST_STR);
		if (NULL == name || '\0' == *name)
			return TRUE;
	}

	return FALSE;
}

static int input_is_num_empty(CTSstruct *contact)
{
	GSList *list = NULL;
	GSList *cursor;

	contacts_svc_struct_get_list(contact, CTS_CF_NUMBER_LIST, &list);

	for (cursor=list;cursor;cursor=cursor->next) {
		const char *number = NULL;

		if (contacts_svc_value_get_bool(cursor->data, CTS_NUM_VAL_DELETE_BOOL))
			continue;

		number = contacts_svc_value_get_str(cursor->data, CTS_NUM_VAL_NUMBER_STR);
		if (number && *number)
			return FALSE;
	}
	return TRUE;
}

static int input_is_email_empty(CTSstruct *contact)
{
	GSList *list = NULL;
	GSList *cursor;

	contacts_svc_struct_get_list(contact, CTS_CF_EMAIL_LIST, &list);

	for (cursor=list;cursor;cursor=cursor->next) {
		bool is_del;
		const char *email = NULL;

		is_del = contacts_svc_value_get_bool(cursor->data, CTS_EMAIL_VAL_DELETE_BOOL);
		if (is_del) continue;

		email = contacts_svc_value_get_str(cursor->data, CTS_EMAIL_VAL_ADDR_STR);
		if (email && *email)
			return FALSE;
	}
	return TRUE;
}

static void input_btn_popup(ct_detail_data *cdetail_d, const char *desc)
{
	Evas_Object *popup;
	Evas_Object *btn;

	popup = elm_popup_add(cdetail_d->navi);
	evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
	elm_object_text_set(popup, desc);

	btn = elm_button_add(popup);
	elm_object_text_set(btn, S_(PH_SYS_SK_OK));
	elm_object_part_content_set(popup, "button1", btn);
	elm_object_style_set(btn, "popup_button/default");
	evas_object_smart_callback_add(btn, "clicked", ct_detail_popup_hide_cb, cdetail_d);

	cdetail_d->popup = popup;
	evas_object_show(popup);
}

void ct_input_save_cb(void *data, Evas_Object *obj, void *event_info)
{
	int ret;
	ct_detail_data *cdetail_d;
	ct_input_data *cinput_d = data;

	p_retm_if(NULL == cinput_d, "cinput_d is NULL");

	cdetail_d = cinput_d->cdetail_d;

	if (TRUE != (ret = ct_input_valid_email(cinput_d->contact))) {
		input_btn_popup(cdetail_d, T_(CT_GET_TEXT_ERR, CTTEXT_INVALID_EMAIL));
		return;
	}

	if (input_is_name_empty(cinput_d->contact)
			&& input_is_num_empty(cinput_d->contact)
			&& input_is_email_empty(cinput_d->contact)) {
		input_btn_popup(cdetail_d, T_(CT_GET_TEXT_ERR, CTTEXT_SAVE_FAIL));
		return;
	}

	if (cinput_d->contact_id) {
		ret = contacts_svc_update_contact(cinput_d->contact);
		if (ret < CTS_SUCCESS) {
			switch (ret) {
			case CTS_ERR_DB_LOCK:
				ERR("contacts_svc_update_contact() Failed(%d)", ret);
				phone_show_popup(cdetail_d->navi, T_(CT_GET_TEXT_ERR, CTTEXT_ERR_DB_LOCKED), 1.5);
				break;
			case CTS_ERR_NO_SPACE:
				ERR("contacts_svc_update_contact() Failed(%d)", ret);
				phone_show_popup(cdetail_d->navi, S_(CT_SYS_POP_NOT_ENOUGH_MEMORY), 1.5);
				break;
			default:
				ERR("contacts_svc_update_contact() Failed(%d)", ret);
				phone_show_popup(cdetail_d->navi, S_(PH_SYS_POP_FAILED), 1.5);
				break;
			}
			return;
		}
		else {
			cinput_d->saved = true;
		}
	}
	else {
		ret = contacts_svc_insert_contact(cinput_d->base_ab, cinput_d->contact);
		if (ret < CTS_SUCCESS) {
			switch (ret) {
			case CTS_ERR_DB_LOCK:
				ERR("contacts_svc_insert_contact() Failed(%d)", ret);
				phone_show_popup(cdetail_d->navi, T_(CT_GET_TEXT_ERR, CTTEXT_ERR_DB_LOCKED), 1.5);
				break;
			case CTS_ERR_NO_SPACE:
				ERR("contacts_svc_update_contact() Failed(%d)", ret);
				phone_show_popup(cdetail_d->navi, S_(CT_SYS_POP_NOT_ENOUGH_MEMORY), 1.5);
				break;
			default:
				ERR("contacts_svc_insert_contact() Failed(%d)", ret);
				phone_show_popup(cdetail_d->navi, S_(PH_SYS_POP_FAILED), 1.5);
				break;
			}
			return;
		}
		else {
			cdetail_d->contact_id = ret;
		}
		if (NULL == cdetail_d->prev_view_data && cdetail_d->ug)
			phone_ug_return_id(cdetail_d->ug, ret, 0, 0);
	}

	/* evas_object_smart_callback_del() func will be deleted */
	evas_object_smart_callback_del(obj, "clicked", ct_input_save_cb);

	if (cdetail_d->prev_view_data && ((CT_UG_REQUEST_UPDATE_CONTACT <= cdetail_d->ug_request &&
					cdetail_d->ug_request <= CT_UG_REQUEST_SAVE_RINGTONE) ||
				(PH_UG_REQUEST_SET_WITH_NUM <= cdetail_d->ug_request &&
				 cdetail_d->ug_request <= PH_UG_REQUEST_SET_WITH_RINGTONE))){
		ug_destroy_me(cdetail_d->ug);
	}
	else if (cdetail_d->ug && !cdetail_d->has_detail && NULL == cdetail_d->prev_view_data) {
		ug_destroy_me(cdetail_d->ug);
	}
	else if (cdetail_d->vcard)
		elm_exit();
	else
		elm_naviframe_item_pop(cdetail_d->navi);
}

CTSvalue* ct_input_get_event(CTSstruct *contact, int event_type)
{
	GSList *list=NULL, *cursor;

	contacts_svc_struct_get_list(contact, CTS_CF_EVENT_LIST, &list);

	for (cursor=list;cursor;cursor=cursor->next) {
		int type = contacts_svc_value_get_int(cursor->data, CTS_EVENT_VAL_TYPE_INT);
		if (event_type == type)
			return cursor->data;
	}
	return NULL;
}

CTSvalue* ct_input_get_nickname(CTSstruct *contact)
{
	GSList *list=NULL;
	contacts_svc_struct_get_list(contact, CTS_CF_NICKNAME_LIST, &list);

	if (NULL == list) return NULL;
	return list->data;
}

CTSvalue* ct_input_get_website_value(CTSstruct* contact)
{
	GSList *list = NULL;
	contacts_svc_struct_get_list(contact, CTS_CF_WEB_ADDR_LIST, &list);

	if (0 < g_slist_length(list))
		return list->data;
	return NULL;
}

int ct_input_get_number_type(int ct_num_type)
{
	int ret_type;

	switch (ct_num_type) {
	case CTTEXT_TYPE_MOBILE:
		ret_type = CTS_NUM_TYPE_CELL;
		break;
	case CTTEXT_TYPE_HOME:
		ret_type = CTS_NUM_TYPE_VOICE | CTS_NUM_TYPE_HOME;
		break;
	case CTTEXT_TYPE_HOME2:
		ret_type = CTS_NUM_TYPE_CELL | CTS_NUM_TYPE_HOME;
		break;
	case CTTEXT_TYPE_WORK:
		ret_type = CTS_NUM_TYPE_VOICE | CTS_NUM_TYPE_WORK;
		break;
	case CTTEXT_TYPE_WORK2:
		ret_type = CTS_NUM_TYPE_CELL | CTS_NUM_TYPE_WORK;
		break;
	case CTTEXT_TYPE_FAX_HOME:
		ret_type = CTS_NUM_TYPE_FAX | CTS_NUM_TYPE_HOME;
		break;
	case CTTEXT_TYPE_FAX_WORK:
		ret_type = CTS_NUM_TYPE_FAX | CTS_NUM_TYPE_WORK;
		break;
	case CTTEXT_TYPE_ASSISTANT:
		ret_type = CTS_NUM_TYPE_ASSISTANT;
		break;
	case CTTEXT_TYPE_PAGER:
		ret_type = CTS_NUM_TYPE_PAGER;
		break;
	case CTTEXT_TYPE_CAR:
		ret_type = CTS_NUM_TYPE_CAR;
		break;
	case CTTEXT_TYPE_OTHER:
	default:
		ret_type = CTS_NUM_TYPE_NONE;
		break;
	}

	return ret_type;
}

static void input_img_del_cb(void *data, Evas_Object *obj, void *event_info)
{
	int ret;
	CTSvalue *value;
	ct_input_data *cinput_d = data;

	p_retm_if(NULL == cinput_d, "parameter(cinput_d) is NULL");

	value = ct_detail_get_baseinfo_value(cinput_d->contact);

	ret  = contacts_svc_value_set_str(value, CTS_BASE_VAL_IMG_PATH_STR, NULL);
	p_warn_if(CTS_SUCCESS != ret, "contacts_svc_value_set_str() failed(%d)", ret);

	ret = contacts_svc_value_set_str(value, CTS_BASE_VAL_FULL_IMG_PATH_STR, NULL);
	p_warn_if(CTS_SUCCESS != ret, "contacts_svc_value_set_str() failed(%d)", ret);

	ct_input_update_image(cinput_d);

	evas_object_del(cinput_d->cdetail_d->popup);
	cinput_d->cdetail_d->popup = NULL;
}

void ct_input_contact_image_change_popup(ct_input_data *cinput_d, bool has_photo)
{
	int rotate;
	Evas_Object *popup;
	int battery_status = -1;

	p_retm_if(NULL == cinput_d, "parameter(cinput_d) is NULL");

	popup = elm_ctxpopup_add(cinput_d->cdetail_d->navi);
	p_retm_if(NULL == popup, "elm_ctxpopup_add() return NULL");

	rotate = (int)evas_object_data_get(cinput_d->cdetail_d->navi, "phone_rotate");
	if (0 == rotate || 180 == rotate)
		elm_ctxpopup_direction_priority_set(popup, ELM_CTXPOPUP_DIRECTION_DOWN, ELM_CTXPOPUP_DIRECTION_UP, ELM_CTXPOPUP_DIRECTION_LEFT, ELM_CTXPOPUP_DIRECTION_RIGHT);

	evas_object_smart_callback_add(popup, "dismissed", ct_detail_popup_hide_cb, cinput_d->cdetail_d);
	evas_object_data_set(popup, "cinput_d", cinput_d);

	if (has_photo) {
		elm_ctxpopup_item_append(popup, T_(CT_GET_TEXT_BASE_OP, CTTEXT_DELETE_PHOTO), NULL,
				input_img_del_cb, cinput_d);
	}

	elm_ctxpopup_item_append(popup, T_(CT_GET_TEXT_BASE_OP, CTTEXT_IMAGE), NULL,
			ct_input_gallery, cinput_d);

	vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &battery_status);
	if (VCONFKEY_SYSMAN_BAT_POWER_OFF != battery_status)
		elm_ctxpopup_item_append(popup, T_(CT_GET_TEXT_BASE_OP, CTTEXT_TAKE_A_PHOTO), NULL,
				ct_input_camera, cinput_d);

	cinput_d->cdetail_d->popup = popup;

	phone_move_ctxpopup(popup, elm_object_part_content_get(cinput_d->ly_baseinfo, "elm.icon.image"));
	evas_object_show(popup);
}

void ct_input_entry_changed_cb(void *data, Evas_Object *obj, void *event_info)
{
	if (elm_object_focus_get(obj)) return;
	evas_object_smart_callback_call(obj, "unfocused", NULL);
}

Evas_Object* ct_input_add_editfield(Evas_Object *parent, const char* guide_txt,
		Evas_Smart_Cb unfocused_cb, void *unfocused_cb_data)
{
	Evas_Object *editfield;
	Evas_Object *entry;

	editfield = ctui_create_editfield(parent, NULL, guide_txt, false);
	p_retvm_if(NULL == editfield, NULL, "ctui_create_editfield() return NULL");

	entry = elm_object_part_content_get(editfield, "elm.swallow.content");
	evas_object_smart_callback_add(entry, "changed", ct_input_entry_changed_cb, editfield);

	if (unfocused_cb)
		evas_object_smart_callback_add(entry, "unfocused", unfocused_cb, unfocused_cb_data);

	return editfield;
}

static int input_get_ct_number_type(int cts_num_type)
{
	if (cts_num_type & CTS_NUM_TYPE_CUSTOM)
		return CTTEXT_TYPE_OTHER;
	else if (cts_num_type & CTS_NUM_TYPE_CELL)
		return CTTEXT_TYPE_MOBILE;
	else if (cts_num_type & CTS_NUM_TYPE_VOICE) {
		if (cts_num_type & CTS_NUM_TYPE_HOME)
			return CTTEXT_TYPE_HOME2;
		else if (cts_num_type & CTS_NUM_TYPE_WORK)
			return CTTEXT_TYPE_WORK2;
		else
			return CTTEXT_TYPE_TELEPHONE;
	}
	else if (cts_num_type & CTS_NUM_TYPE_FAX) {
		if (cts_num_type & CTS_NUM_TYPE_HOME)
			return CTTEXT_TYPE_FAX_HOME;
		else if (cts_num_type & CTS_NUM_TYPE_WORK)
			return CTTEXT_TYPE_FAX_WORK;
		else
			return CTTEXT_TYPE_FAX;
	}
	else if (cts_num_type & CTS_NUM_TYPE_PAGER)
		return CTTEXT_TYPE_PAGER;
	else if (cts_num_type & CTS_NUM_TYPE_CAR)
		return CTTEXT_TYPE_CAR;
	else if (cts_num_type & CTS_NUM_TYPE_ASSISTANT)
		return CTTEXT_TYPE_ASSISTANT;
	else
		return CTTEXT_TYPE_OTHER;

}

int ct_input_next_number_type(CTSstruct *contact)
{
	int i;
	int used = 0;
	int cts_type;
	GSList *list = NULL, *cursor;
	contacts_svc_struct_get_list(contact, CTS_CF_NUMBER_LIST, &list);

	for (cursor=list;cursor;cursor=cursor->next) {
		if (contacts_svc_value_get_bool(cursor->data, CTS_NUM_VAL_DELETE_BOOL))
			continue;

		cts_type = contacts_svc_value_get_int(cursor->data, CTS_NUM_VAL_TYPE_INT);
		used |= 1<<input_get_ct_number_type(cts_type);
	}

	for (i=CTTEXT_TYPE_MOBILE;i<CTTEXT_TYPE_OTHER;i++)  {
		if (!(used & 1<<i))
			return i;
	}
	return CTTEXT_TYPE_OTHER;
}

int ct_input_next_email_type(CTSstruct *contact)
{
	int i;
	int used = 0;
	GSList *list = NULL, *cursor;
	contacts_svc_struct_get_list(contact, CTS_CF_EMAIL_LIST, &list);

	for (cursor=list;cursor;cursor=cursor->next) {
		if (contacts_svc_value_get_bool(cursor->data, CTS_EMAIL_VAL_DELETE_BOOL))
			continue;

		used |= 1<<contacts_svc_value_get_int(cursor->data, CTS_EMAIL_VAL_TYPE_INT);
	}

	for (i=CTS_EMAIL_TYPE_HOME;i<=CTS_EMAIL_TYPE_WORK;i++) {
		if (!(used & 1<<i))
			return i;
	}

	return CTS_EMAIL_TYPE_NONE;
}

int ct_input_next_addr_type(CTSstruct *contact)
{
	int i;
	int type = CTS_ADDR_TYPE_NONE;
	GSList *list = NULL, *cursor;
	contacts_svc_struct_get_list(contact, CTS_CF_POSTAL_ADDR_LIST, &list);

	for (cursor=list;cursor;cursor=cursor->next) {
		if (contacts_svc_value_get_bool(cursor->data, CTS_POSTAL_VAL_DELETE_BOOL))
			continue;

		type |= contacts_svc_value_get_int(cursor->data, CTS_POSTAL_VAL_TYPE_INT);
	}

	for (i=CTS_ADDR_TYPE_HOME;i<=CTS_ADDR_TYPE_WORK;i++) {
		if (!(type & i))
			return i;
	}

	return CTS_ADDR_TYPE_NONE;
}

int ct_input_next_web_type(CTSstruct *contact)
{
	int i;
	int used = 0;
	GSList *list = NULL, *cursor;
	contacts_svc_struct_get_list(contact, CTS_CF_WEB_ADDR_LIST, &list);

	for (cursor=list;cursor;cursor=cursor->next) {
		if (contacts_svc_value_get_bool(cursor->data, CTS_WEB_VAL_DELETE_BOOL))
			continue;

		used |= 1<<contacts_svc_value_get_int(cursor->data, CTS_WEB_VAL_TYPE_INT);
	}

	for (i=CTS_WEB_TYPE_HOME;i<=CTS_WEB_TYPE_WORK;i++) {
		if (!(used & 1<<i))
			return i;
	}

	return CTS_WEB_TYPE_NONE;
}

int ct_input_next_messenger_type(CTSstruct *contact)
{
	int i;
	int used = 0;
	GSList *list = NULL, *cursor;
	contacts_svc_struct_get_list(contact, CTS_CF_MESSENGER_LIST, &list);

	for (cursor=list;cursor;cursor=cursor->next) {
		if (contacts_svc_value_get_bool(cursor->data, CTS_MESSENGER_VAL_DELETE_BOOL))
			continue;

		used |= 1<<contacts_svc_value_get_int(cursor->data, CTS_MESSENGER_VAL_TYPE_INT);
	}

	for (i=CTS_IM_TYPE_GOOGLE;i<=CTS_IM_TYPE_IRC;i++) {
		if (!(used & 1<<i))
			return i;
	}

	return CTS_IM_TYPE_NONE;
}


Evas_Object* ct_input_create_dg_layout(Evas_Object *parent, const char *theme)
{
	Evas_Object *layout = elm_layout_add(parent);
	p_retvm_if(NULL == layout, NULL, "elm_layout_add() return NULL");

	elm_layout_theme_set(layout, "layout", "dialogue", theme);
	evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, 0.0);
	evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, 0.0);

	evas_object_show(layout);
	return layout;
}

void ct_input_typed_layout_del_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
	ct_input_typed_data *typed_data = data;
	free(typed_data);
}

void ct_input_update_ringtone(CTSstruct *contact, Evas_Object *layout)
{
	int ret;
	CTSvalue *value;
	const char *display;
	const char *temp;
	Evas_Object *btn;

	ret = contacts_svc_struct_get_value(contact, CTS_CF_BASE_INFO_VALUE, &value);
	p_retm_if(CTS_SUCCESS != ret && CTS_ERR_NO_DATA != ret, "contacts_svc_struct_get_value() Failed(%d)", ret);

	temp = contacts_svc_value_get_str(value, CTS_BASE_VAL_RINGTONE_PATH_STR);
	display = ct_detail_get_ringtone_display_name(temp);
	elm_object_part_text_set(layout, "elm.text.2", display);

	btn = elm_object_part_content_get(layout, "elm.icon");
	p_retm_if(NULL == btn, "elm_object_part_content_get() return NULL");

	if (NULL == temp || '\0' == *temp) {
		elm_object_focus_set(btn, EINA_FALSE);
		elm_object_disabled_set(btn, EINA_TRUE);
	}
	else
		elm_object_disabled_set(btn, EINA_FALSE);
}

unsigned int ct_input_box_idx_get(Evas_Object *box, Evas_Object *obj)
{
	int count = 0;
	Eina_List *list, *cursor;
	Evas_Object *data;
	list = elm_box_children_get(box);

	EINA_LIST_FOREACH(list, cursor, data) {
		if (data == obj)
			break;
		count++;
	}
	eina_list_free(list);
	return count;
}

void ct_input_save_button_update(ct_input_data *cinput_d)
{
	Evas_Object *save_btn;
	p_retm_if(NULL == cinput_d, "parameter(cinput_d) is NULL");

	save_btn = elm_object_item_part_content_get(cinput_d->navi_item, "title_left_btn");
	if (save_btn)
		elm_object_disabled_set(save_btn, cinput_d->save_disable);

	if (cinput_d->save_btn)
		elm_object_item_disabled_set(cinput_d->save_btn, cinput_d->save_disable);
}

static inline Eina_Bool input_is_editfield_empty(Evas_Object *editfield)
{
	const char *val;
	Evas_Object *entry;

	entry = elm_object_part_content_get(editfield, "elm.swallow.content");
	p_retvm_if(NULL == entry, EINA_FALSE, "elm_object_part_content_get() return NULL");

	val = elm_entry_entry_get(entry);
	if (val && *val)
		return EINA_FALSE;

	return EINA_TRUE;
}

static void input_name_field_changed_cb(void *data, Evas_Object *obj, void *event_info)
{
	int idx;
	Evas_Object *ly;
	Evas_Object *ly_content;
	Evas_Object *ef;
	Eina_List *list;
	ct_input_data *cinput_d = data;
	p_retm_if(NULL == cinput_d, "parameter(cinput_d) is NULL");

	ef = elm_object_part_content_get(cinput_d->ly_baseinfo, "elm.icon.name1");
	if (EINA_FALSE == input_is_editfield_empty(ef)) {
		if (EINA_FALSE == cinput_d->save_disable)
			return;
		cinput_d->save_disable = EINA_FALSE;
		ct_input_save_button_update(cinput_d);
		return;
	}

	ef = elm_object_part_content_get(cinput_d->ly_baseinfo, "elm.icon.name2");
	if (EINA_FALSE == input_is_editfield_empty(ef)) {
		if (EINA_FALSE == cinput_d->save_disable)
			return;
		cinput_d->save_disable = EINA_FALSE;
		ct_input_save_button_update(cinput_d);
		return;
	}

	list = elm_box_children_get(cinput_d->box);

	ly = cinput_d->ly_number_first;
	idx = ct_input_box_idx_get(cinput_d->box, ly);
	while (ly) {
		ly_content = elm_object_part_content_get(ly, "elm.swallow.decorate.content");
		ef = elm_object_part_content_get(ly_content, "elm.flip.content");
		if (EINA_FALSE == input_is_editfield_empty(ef)) {
			if (EINA_FALSE == cinput_d->save_disable) {
				eina_list_free(list);
				return;
			}
			cinput_d->save_disable = EINA_FALSE;
			ct_input_save_button_update(cinput_d);
			eina_list_free(list);
			return;
		}
		if (ly == cinput_d->ly_number_last)
			break;
		ly = eina_list_nth(list, ++idx);
	}

	ly = cinput_d->ly_email_first;
	idx = ct_input_box_idx_get(cinput_d->box, ly);
	while (ly) {
		ly_content = elm_object_part_content_get(ly, "elm.swallow.decorate.content");
		ef = elm_object_part_content_get(ly_content, "elm.flip.content");
		if (EINA_FALSE == input_is_editfield_empty(ef)) {
			if (EINA_FALSE == cinput_d->save_disable) {
				eina_list_free(list);
				return;
			}
			cinput_d->save_disable = EINA_FALSE;
			ct_input_save_button_update(cinput_d);
			eina_list_free(list);
			return;
		}
		if (ly == cinput_d->ly_email_last)
			break;
		ly = eina_list_nth(list, ++idx);
	}

	eina_list_free(list);

	if (EINA_TRUE == cinput_d->save_disable)
		return;
	cinput_d->save_disable = EINA_TRUE;
	ct_input_save_button_update(cinput_d);
}

void ct_input_name_field_add(Evas_Object *editfield, ct_input_data *cinput_d)
{
	Evas_Object *entry;

	p_retm_if(NULL == cinput_d, "parameter(cinput_d) is NULL");
	p_retm_if(NULL == editfield, "parameter(editfield) is NULL");

	entry = elm_object_part_content_get(editfield, "elm.swallow.content");
	p_retm_if(NULL == cinput_d, "elm_object_part_content_get() return NULL");

	evas_object_smart_callback_add(entry, "changed", input_name_field_changed_cb, cinput_d);
	evas_object_smart_callback_add(entry, "preedit,changed", input_name_field_changed_cb, cinput_d);
}

int ct_input_get_full_address(CTSvalue *postal, char *buf, int buf_len)
{
	const char *code;
	const char *region;
	const char *locality;
	const char *street;
	const char *extended;
	const char *country;
	const char *pobox;

	code = contacts_svc_value_get_str(postal, CTS_POSTAL_VAL_POSTALCODE_STR);
	extended = contacts_svc_value_get_str(postal, CTS_POSTAL_VAL_EXTENDED_STR);
	pobox = contacts_svc_value_get_str(postal, CTS_POSTAL_VAL_POBOX_STR);
	street = contacts_svc_value_get_str(postal, CTS_POSTAL_VAL_STREET_STR);
	locality = contacts_svc_value_get_str(postal, CTS_POSTAL_VAL_LOCALITY_STR);
	region = contacts_svc_value_get_str(postal, CTS_POSTAL_VAL_REGION_STR);
	country = contacts_svc_value_get_str(postal, CTS_POSTAL_VAL_COUNTRY_STR);

	snprintf(buf, buf_len, "%s%s%s%s%s%s%s%s%s%s%s%s%s", SAFE_STR(code), STR_BLANK(code, extended), STR_BLANK(extended, pobox),
			STR_BLANK(pobox, street), STR_BLANK(street, locality), STR_BLANK(locality, region), STR_BLANK(region, country));

	return 0;
}