/**

  * GMyth Library

  *

  * @file gmyth/gmyth_http.c

  * 

  * @brief <p> GMythHttp class provides a wrapper to access

  * data from the database using http+xml

  *

  * Copyright (C) 2006 INdT - Instituto Nokia de Tecnologia.

  * @author Artur Duque de Souza <@indt.org.br>

  *

  */

 /*

  * 

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU Lesser General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU Lesser General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  */

 #ifdef HAVE_CONFIG_H

 #include "config.h"

 #endif

 #include <assert.h>

 #include <libxml/parser.h>

 #include <libxml/tree.h>

 #include <libxml/xpath.h>

 #include "gmyth_http.h"

 #include "gmyth_debug.h"

 #include "gmyth_socket.h"

 xmlXPathObjectPtr

 getnodeset(xmlDocPtr doc, xmlChar *xpath)

 {

     xmlXPathContextPtr context;

     xmlXPathObjectPtr result;

     context = xmlXPathNewContext(doc);

     result = xmlXPathEvalExpression(xpath, context);

     if(xmlXPathNodeSetIsEmpty(result->nodesetval))

     {

         g_fprintf(stderr, "Error: No result at XPath\n");

         return NULL;

     }

     xmlXPathFreeContext(context);

     return result;

 }

 xmlDocPtr XMLParse (const char *content, int length) 

 {

     xmlDocPtr doc; /* the resulting document tree */

     doc = xmlReadMemory(content, length, NULL, NULL, 0);

     if (doc == NULL) 

     {

         g_fprintf(stderr, "Error: Failed to parse XML document\n");

         return NULL;

     }

     return doc;

 }

 xmlXPathObjectPtr getXPath (xmlChar *xpath, xmlDocPtr doc)

 {

     xmlXPathObjectPtr result;

     result = getnodeset(doc, xpath);

     return result;

 }

 /** Retrieves the Progam List from the Channel

  *

  * @param nodeTab A pointer to a node inside the XML

  * @return A GSList containing a list of all the programs

  */

 GSList* get_Program_List(xmlNodePtr node)

 {

 	GSList* program_list = NULL;

 	while (node != NULL)

 	{

 		if (g_ascii_strcasecmp((char *)node->name, "text") != 0)

 		{

 			GMythProgram* program = (GMythProgram*)g_malloc(sizeof(struct _GMythProgram));

 			program->title = g_string_new((char *)xmlGetProp(node, (xmlChar *)"title"));

 			program->subtitle = g_string_new((char *)xmlGetProp(node, (xmlChar *)"subtitle"));

 			program->catType = g_string_new((char *)xmlGetProp(node, (xmlChar *)"catType"));

     		program->category = g_string_new((char *)xmlGetProp(node, (xmlChar *)"category"));

 			sscanf ((char *)xmlGetProp(node, (xmlChar *)"repeat"), "%d", &(program->repeat));

 			program->startTime = gmyth_util_string_to_time_val ((char *)xmlGetProp(node, \

 																		(xmlChar *)"startTime"));

 			program->endTime = gmyth_util_string_to_time_val ((char *)xmlGetProp(node, \

 																		(xmlChar *)"endTime"));

 			program_list = g_slist_append(program_list, program);

 		}

 		node = node->next;

 	}

 	return program_list;

 }

 /** Retrieves the Channel List from the ProgramGuide

  *

  * @param node A pointer to a node inside the XML

  * @param epg The struct where is the current epg

  * @return The epg from "param" updated

  */

 void get_Channel_List (xmlNodePtr node, GMythEpg* epg)

 {

 	int i;

 	epg->channelList = NULL;

 	for (i=1; i <= epg->numOfChannels; i++)

 	{

 		GMythChannel* channel = (GMythChannel*)g_malloc(sizeof(struct _GMythChannel));

 		channel->channelName = g_string_new((char *)xmlGetProp(node, (xmlChar *)"channelName"));

 		channel->chanNum = g_string_new((char *)xmlGetProp(node, (xmlChar *)"chanNum"));

 		sscanf ((char *)xmlGetProp(node, (xmlChar *)"chanId"), "%d", &(channel->chanId));

 		sscanf ((char *)xmlGetProp(node, (xmlChar *)"callSign"), "%d", &(channel->callSign));

 		channel->programList = get_Program_List(node->children);

 		epg->channelList = g_slist_append(epg->channelList, channel);

 	}

 }

 /** Retrieves the properties from the ProgramGuide

  *

  * @param nodeTab A pointer to a node inside the XML

  * @param epg The struct where is the current epg

  * @return The epg from "param" updated

  */

 void get_ProgramGuide_Properties (xmlNodePtr nodeTab, GMythEpg* epg)

 {

 	sscanf ((char *)xmlGetProp(nodeTab, (xmlChar *)"startChanId"), "%d", &(epg->startChanId));

 	sscanf ((char *)xmlGetProp(nodeTab, (xmlChar *)"endChanId"), "%d", &(epg->endChanId));

 	epg->version = g_string_new((char *)xmlGetProp(nodeTab, (xmlChar *)"version"));

 	sscanf ((char *)xmlGetProp(nodeTab, (xmlChar *)"protoVer"), "%d", &(epg->protoVer));

 	sscanf ((char *)xmlGetProp(nodeTab, (xmlChar *)"totalCount"), "%d", &(epg->totalCount));

 	sscanf ((char *)xmlGetProp(nodeTab, (xmlChar *)"numOfChannels"), "%d", &(epg->numOfChannels));

 	epg->asOf = gmyth_util_string_to_time_val ((char *)xmlGetProp(nodeTab, (xmlChar *)"asOf"));

 	epg->startTime = gmyth_util_string_to_time_val ((char *)xmlGetProp(nodeTab, (xmlChar *)"startTime"));

 	epg->endTime = gmyth_util_string_to_time_val ((char *)xmlGetProp(nodeTab, (xmlChar *)"endTime"));

 	sscanf ((char *)xmlGetProp(nodeTab, (xmlChar *)"details"), "%d", &(epg->details));

 	// go to Channel section and retrieve Channels and Programs

 	get_Channel_List(nodeTab->children->next->children->next, epg);

 }

 /** Aux function to retrieve the Eletronic Program Guide

  *

  * @param doc An XML document (xmlDocPtr)

  * @return The epg

  */

 void getEpg (xmlDocPtr doc, GMythEpg* epg)

 {

     xmlXPathObjectPtr result;

     xmlNodeSetPtr nodeset;

     xmlChar *keyword;

     int i;

     result = getXPath((xmlChar *)"/*", doc);

     if (result) 

     {

         nodeset = result->nodesetval;

         for (i=0; i < nodeset->nodeNr; i++) 

 		{

 			keyword = (xmlChar*)nodeset->nodeTab[i]->name;

 			if (g_ascii_strcasecmp((char *)keyword, "ProgramGuide") == 0)

 				get_ProgramGuide_Properties(nodeset->nodeTab[i], epg);

 		}

         xmlXPathFreeObject (result);

     }

 }

 /** Retrieves the Eletronic Program Guide from the backend

  *

  * @param doc An XML document (xmlDocPtr)

  * @return The epg

  */

 GMythEpg retrieve_epg (GMythBackendInfo *backend_info, int port, \

 						GTimeVal* StartTime, GTimeVal* EndTime, \

 						gint StartChanId, gint NumOfChannels, \

 						gchar* Details)

 {

 	GMythEpg epg;

 	MemoryStruct chunk;

     chunk.memory=NULL; /* we expect realloc(NULL, size) to work */

     chunk.size = 0;    /* no data at this point */

 	gchar* starttime = (gchar*)g_malloc(sizeof(gchar)*20);

 	starttime = gmyth_util_time_to_mythformat_from_time_val(StartTime);

 	gchar* endtime = (gchar*)g_malloc(sizeof(gchar)*20);

 	endtime = gmyth_util_time_to_mythformat_from_time_val(EndTime);

 	GString* command = g_string_new("");

 	g_string_printf(command, "getProgramGuide?StartTime=%s&EndTime=%s&StartChanId=%d"

 							 "&NumOfChannels=%d&Details=%s", starttime, endtime, \

 							 StartChanId, NumOfChannels, Details);

 	chunk = gmyth_http_request(backend_info, command);

     xmlDocPtr doc = XMLParse(chunk.memory, strlen(chunk.memory));

     getEpg(doc, &epg);

     free(chunk.memory);

 	return epg;

 }

 /* Aux functions got from libcurl */

 void *myrealloc (void *ptr, size_t size)

 {

     /* There might be a realloc() out there that doesn't like reallocing

         NULL pointers, so we take care of it here */

     if(ptr)

         return realloc(ptr, size);

     else

         return malloc(size);

 }

 size_t

 WriteMemoryCallback (void *ptr, size_t size, size_t nmemb, void *data)

 {

 	size_t realsize = size * nmemb;

 	MemoryStruct *mem = (struct _MemoryStruct *)data;

 	mem->memory = (char *)myrealloc(mem->memory, mem->size + realsize + 1);

 	if (mem->memory) 

 	{

 		memcpy(&(mem->memory[mem->size]), ptr, realsize);

 		mem->size += realsize;

 		mem->memory[mem->size] = 0;

 	}

 	return realsize;

 }

 /** Create a String containing the URL with the command

  *

  * @param command A string with the command

  * @param variables Vars to use with their values \

  *                    MUST FINISH WITH NULL!!!

  * @return The response

  */

 GString* gmyth_http_create_command (GString *command, ...)

 {

     va_list args;

     va_start(args, command);

     gchar* s = NULL;

     g_string_append(command, "?");

     /* Sintax: var, value */

     while ( (s = va_arg(args, gchar *)) != NULL ) 

     {

         g_string_append(command, s);

         g_string_append(command, "=");

         s = va_arg(args, gchar *);

         g_string_append(command, s);

         g_string_append(command, "&");

     }

     free(s);

     va_end(args);

     return command;

 }

 /** Send HTTP Command and receives the result of it

  *

  * @return A string with the response from the server

  *          NULL if there is no response.

  */

 MemoryStruct gmyth_http_request (GMythBackendInfo *backend_info, GString *command)

 {

     LIBXML_TEST_VERSION

     size_t size = strlen(backend_info->hostname) + strlen(command->str) + 13;

     gchar *URL = (gchar *)g_malloc(sizeof(gchar)*size);

     g_snprintf(URL, size+1, "http://%s:6544/%s", backend_info->hostname, command->str);

     CURL *curl_handle;

     MemoryStruct chunk;

     chunk.memory=NULL; /* we expect realloc(NULL, size) to work */

     chunk.size = 0;    /* no data at this point */

     curl_global_init(CURL_GLOBAL_ALL);

     /* init the curl session */

     curl_handle = curl_easy_init();

     /* specify URL to get */

     curl_easy_setopt(curl_handle, CURLOPT_URL, URL);

     /* send all data to this function  */

     curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);

     /* we pass our 'chunk' struct to the callback function */

     curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);

     /* some servers don't like requests that are made without a user-agent

         field, so we provide one */

     curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");

     /* get it! */

     curl_easy_perform(curl_handle);

     /* cleanup curl stuff */

     curl_easy_cleanup(curl_handle);

     return chunk;

 }