/*
 * Copyright (c) 2015 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 <Elementary.h>
#include <media_content.h>
#include <app_debug.h>
#include <app_contents.h>
#include <app_media.h>
#include <gridmgr.h>
#include <inputmgr.h>
#include <viewmgr.h>

#include "define.h"
#include "view.h"
#include "data/datamgr.h"
#include "grid/grid.h"
#include "util/util.h"

#define STR_PLACE_NAME "City"

static void _create_thumbnail_completed_cb(media_content_error_e err,
			const char *path, void *user_data)
{
	Elm_Object_Item *it;
	app_media *am;

	if (!user_data)
		return;

	it = user_data;

	media_content_connect();

	am = elm_object_item_data_get(it);

	app_media_update(am);

	elm_gengrid_item_fields_update(it, PART_ELM_SWALLOW_THUMBNAIL,
				ELM_GENGRID_ITEM_FIELD_CONTENT);

	media_content_disconnect();
}

static char *_media_text_get(void *data, Evas_Object *obj, const char *part)
{
	app_media *am;
	app_media_info *info;
	char buf[32];

	if (!data)
		return NULL;

	am = data;

	info = app_media_get_info(am);
	if (!info) {
		_ERR("failed to get media info");
		return NULL;
	}

	if (info->media_type != MEDIA_CONTENT_TYPE_VIDEO)
		return NULL;

	if (!strcmp(part, PART_ELM_TEXT_PLAYTIME)) {
		util_time_string(buf, sizeof(buf),
					info->video->duration, false);

		return strdup(buf);
	}

	return NULL;
}

static Evas_Object *_media_content_get(void *data,
			Evas_Object *obj, const char *part)
{
	Evas_Object *eo;
	app_media *am;
	app_media_info *info;

	if (!data)
		return NULL;

	am = data;

	info = app_media_get_info(am);
	if (!info) {
		_ERR("failed to get media info");
		return NULL;
	}

	eo = NULL;
	if (!strcmp(part, PART_ELM_SWALLOW_THUMBNAIL)) {
		if (!info->thumbnail_path) {
			util_create_thumbnail(obj, am,
				_create_thumbnail_completed_cb);
			return NULL;
		}

		eo = util_add_image(obj, info->thumbnail_path);
		if (!eo) {
			_ERR("failed to create image object");
			return NULL;
		}
	} else if (!strcmp(part, PART_ELM_SWALLOW_PICTURE)) {
		if (info->media_type != MEDIA_CONTENT_TYPE_IMAGE)
			return NULL;

		if (info->thumbnail_path)
			return NULL;

		eo = util_add_image(obj, IMAGE_THUMBNAIL_PICTURE);
		if (!eo) {
			_ERR("failed to create image object");
			return NULL;
		}
	} else if (!strcmp(part, PART_ELM_SWALLOW_VIDEO)) {
		if (info->media_type != MEDIA_CONTENT_TYPE_VIDEO)
			return NULL;

		eo = util_add_image(obj, IMAGE_THUMBNAIL_PLAY);
		if (!eo) {
			_ERR("failed to create image object");
			return NULL;
		}
	} else if (!strcmp(part, PART_ELM_SWALLOW_FAVORITE)) {
		if (!info->favorite)
			return NULL;

		eo = util_add_image(obj, IMAGE_THUMBNAIL_FAVORITE);
		if (!eo) {
			_ERR("failed to create image object");
			return NULL;
		}
	}

	if (eo)
		evas_object_show(eo);

	return eo;
}

static char *_place_text_get(void *data, Evas_Object *obj, const char *part)
{
	struct group_info *gi;
	int cnt;
	char buf[64];
	char *city, *country, *tmp;

	if (!data)
		return NULL;

	gi = data;

	snprintf(buf, sizeof(buf), "%s", gi->name);
	city = strtok_r(buf, "/", &tmp);
	country = strtok_r(tmp, "", &tmp);

	if (!strcmp(part, PART_ELM_TEXT_COUNT)) {
		cnt = eina_list_count(gi->list);
		snprintf(buf, sizeof(buf), "%d", cnt);
		return strdup(buf);
	} else if (!strcmp(part, PART_ELM_TEXT_CITY)) {
		if (!city)
			return NULL;

		return strdup(city);
	} else if (!strcmp(part, PART_ELM_TEXT_COUNTRY)) {
		if (!country)
			return NULL;

		return strdup(country);
	}

	return NULL;
}

static Evas_Object *_place_content_get(void *data, Evas_Object *obj,
			const char *part)
{
	Evas_Object *eo;
	struct group_info *gi;
	struct color_data bg;

	if (!data)
		return NULL;

	gi = data;

	eo = NULL;
	if (!strcmp(part, PART_ELM_SWALLOW_BG)) {
		eo = evas_object_rectangle_add(obj);
		if (!eo) {
			_ERR("failed to create rectangle object");
			return NULL;
		}

		app_contents_get_color(gi->name, &bg, NULL);
		evas_object_color_set(eo, bg.r, bg.g, bg.b, bg.a);

		evas_object_show(eo);
	}

	return eo;
}

static Eina_List *_get_event_list(struct datamgr *dmgr)
{
	if (!dmgr) {
		_ERR("invalid argument");
		return NULL;
	}

	return dmgr->ops->get_group(dmgr->handle, E_GROUP_MEDIA_DATE, NULL);
}

static Eina_List *_get_place_list(struct datamgr *dmgr)
{
	Eina_List *list;
	struct group_info *gi;

	if (!dmgr) {
		_ERR("invalid argument");
		return NULL;
	}

	gi = calloc(1, sizeof(*gi));
	if (!gi) {
		_ERR("failed to allocate memory");
		return NULL;
	}

	gi->name = STR_PLACE_NAME;
	gi->list = dmgr->ops->get_group(dmgr->handle,
				E_GROUP_MEDIA_PLACE, NULL);

	list = NULL;
	list = eina_list_append(list, gi);

	return list;
}

static Eina_List *_get_type_list(struct datamgr *dmgr)
{
	if (!dmgr) {
		_ERR("invalid argument");
		return NULL;
	}

	return dmgr->ops->get_group(dmgr->handle, E_GROUP_MEDIA_TYPE, NULL);
}

static void _free_media_list(struct datamgr *dmgr, Eina_List *list)
{
	if (!dmgr) {
		_ERR("invalid argument");
		return;
	}

	dmgr->ops->free_group(list);
}

static void _free_place_list(struct datamgr *dmgr, Eina_List *list)
{
	struct group_info *gi;

	if (!dmgr) {
		_ERR("invalid argument");
		return;
	}

	EINA_LIST_FREE(list, gi) {
		dmgr->ops->free_group(gi->list);
		free(gi);
	}
}

static void _get_media_info(struct datamgr *dmgr, Eina_List *list, char *str,
			int size)
{
	int photo, video;

	photo = dmgr->ops->get_count(dmgr->handle, E_FILE_PHOTO);
	video = dmgr->ops->get_count(dmgr->handle, E_FILE_VIDEO);

	if (photo < 0) {
		_ERR("failed to get media count");
		photo = 0;
	}

	if (video < 0) {
		_ERR("failed to get media count");
		video = 0;
	}

	snprintf(str, size, "%d Photos, %d Videos", photo, video);
}

static void _get_place_info(struct datamgr *dmgr, Eina_List *list, char *str,
			int size)
{
	Eina_List *l;
	struct group_info *gi;
	int cnt;

	cnt = 0;
	EINA_LIST_FOREACH(list, l, gi)
		cnt += eina_list_count(gi->list);

	snprintf(str, size, "%d Cities", cnt);
}

static void _key_down_cb(void *data, Elm_Object_Item *it,
			Evas_Event_Key_Down *ev)
{
	struct view_update_data vdata;
	struct datamgr *dmgr;
	app_media *am;

	if (!data || !ev) {
		_ERR("invalid argument");
		return;
	}

	dmgr = data;

	if (!strcmp(ev->keyname, KEY_MENU) ||
		!strcmp(ev->keyname, KEY_CONTEXT_MENU)) {
		am = elm_object_item_data_get(it);
		if (!am) {
			_ERR("failed to get app media");
			return;
		}

		vdata.list = dmgr->ops->get_list(dmgr->handle,
					E_LIST_MEDIA, NULL);
		vdata.index = util_get_media_index(vdata.list, am);

		viewmgr_update_view(VIEW_ACTION_MENU, UPDATE_CONTENT, &vdata);
		viewmgr_show_view(VIEW_ACTION_MENU);
	}
}

static void _media_selected_cb(void *data, Elm_Object_Item *it)
{
	struct view_update_data vdata;
	struct datamgr *dmgr;
	app_media *am;

	if (!data || !it) {
		_ERR("invalid argument");
		return;
	}

	dmgr = data;

	am = elm_object_item_data_get(it);
	if (!am) {
		_ERR("failed to get app media");
		return;
	}

	vdata.list = dmgr->ops->get_list(dmgr->handle, E_LIST_MEDIA, NULL);
	vdata.index = util_get_media_index(vdata.list, am);
	vdata.id = VIEW_BASE;

	viewmgr_update_view(VIEW_VIEWER, UPDATE_CONTENT, &vdata);
	viewmgr_push_view(VIEW_VIEWER);
}

static void _place_selected_cb(void *data, Elm_Object_Item *it)
{
	struct view_update_data vdata;
	struct group_info *gi;

	if (!it) {
		_ERR("invalid argument");
		return;
	}

	gi = elm_object_item_data_get(it);
	if (!gi) {
		_ERR("failed to get group info");
		return;
	}

	vdata.list = gi->list;
	vdata.index = E_DETAIL_GALLERY_PLACE;
	vdata.id = gi->name;

	viewmgr_update_view(VIEW_DETAIL, UPDATE_CONTENT, &vdata);
	viewmgr_push_view(VIEW_DETAIL);
}

static struct grid_class _gclass[] = {
	[E_GALLERY_EVENT] = {
		.item_style = STYLE_GALLERY_EVENT,
		.text_get = _media_text_get,
		.content_get = _media_content_get
	},
	[E_GALLERY_PLACE] = {
		.item_style = STYLE_GALLERY_PLACE,
		.text_get = _place_text_get,
		.content_get = _place_content_get
	},
	/* Other view mode class will be added later */
};

static struct grid_data _gdata[] = {
	[E_GALLERY_EVENT] = {
		.item_x = GALLERY_EVENT_ITEM_X,
		.item_y = GALLERY_EVENT_ITEM_Y,
		.item_num = GALLERY_EVENT_ITEM_NUM,
		.grid_padding = GALLERY_EVENT_GRID_PADDING,
		.gclass = &_gclass[E_GALLERY_EVENT],
		.get_item_list = _get_event_list,
		.free_item_list = _free_media_list,
		.get_item_info = _get_media_info,
		.key_down_cb = _key_down_cb,
		.selected_cb = _media_selected_cb
	},
	[E_GALLERY_PLACE] = {
		.item_x = GALLERY_PLACE_ITEM_X,
		.item_y = GALLERY_PLACE_ITEM_Y,
		.item_num = GALLERY_PLACE_ITEM_NUM,
		.grid_padding = GALLERY_PLACE_GRID_PADDING,
		.gclass = &_gclass[E_GALLERY_PLACE],
		.get_item_list = _get_place_list,
		.free_item_list = _free_place_list,
		.get_item_info = _get_place_info,
		.selected_cb = _place_selected_cb
	},
	[E_GALLERY_VIDEO] = {
		.item_x = GALLERY_EVENT_ITEM_X,
		.item_y = GALLERY_EVENT_ITEM_Y,
		.item_num = GALLERY_EVENT_ITEM_NUM,
		.grid_padding = GALLERY_EVENT_GRID_PADDING,
		.gclass = &_gclass[E_GALLERY_EVENT],
		.get_item_list = _get_type_list,
		.free_item_list = _free_media_list,
		.get_item_info = _get_media_info,
		.key_down_cb = _key_down_cb,
		.selected_cb = _media_selected_cb
	},
	/* Other view mode data will be added later */
};

struct grid_data *get_gallery_grid_data(int type)
{
	if (type < 0 || type >= E_GALLERY_MAX) {
		_ERR("invalid argument");
		return NULL;
	}

	return &_gdata[type];
}