#include "string.h"
#include "stdio.h"

#include "utils.h"

#include "configure.h"


struct Outline* malloc_outline()
{
	struct Outline* outline = (struct Outline*)malloc(sizeof(struct Outline));

	memset(outline, 0, sizeof(struct Outline));

	outline->htmlUrl = NULL;
	outline->title = NULL;
	outline->type = NULL;
	outline->xmlUrl = NULL;
	outline->kind = 0;
	outline->begintag = NULL;
	outline->endtag = NULL;
	
	
	outline->pNext = NULL;

	return outline;
}

void free_outline(struct Outline* outline)
{
	if(!outline)
		return;

	if(outline->htmlUrl)
		free(outline->htmlUrl);
	if(outline->title)
		free(outline->title);
	if(outline->type)
		free(outline->type);
	if(outline->xmlUrl)
		free(outline->xmlUrl);
	if(outline->begintag)
		free(outline->begintag);
	if(outline->endtag)
		free(outline->endtag);
}


struct Source* malloc_source()
{
	struct Source* source = (struct Source*)malloc(sizeof(struct Source));

	memset(source, 0, sizeof(struct Source));

	source->subkey = 0;
	source->name = NULL;
	source->outline_count = 0;
	
	source->outline = NULL;
	source->pNext = NULL;
	
	return source;
}

void free_source(struct Source* source)
{
	if(!source)
		return;

	if(source->name)
		free(source->name);

	struct Outline* pHead= source->outline;
	struct Outline* pCur = NULL;

	while(pHead)
	{
		free_outline(pHead);

		pCur = pHead->pNext;
		free(pHead);

		pHead = pCur;
	}
}

struct ChannelCuster* malloc_channelcuster()
{
	struct ChannelCuster* channelCuster = (struct ChannelCuster*)malloc(sizeof(struct ChannelCuster));

	memset(channelCuster, 0, sizeof(struct Configure));

	channelCuster->interval = 0;
	channelCuster->key = 0;
	channelCuster->name = NULL;
	channelCuster->source_count = 0;
	
	channelCuster->source = NULL;
	channelCuster->pNext = NULL;
	
	return channelCuster;
}

void free_channelcuster(struct ChannelCuster* channelCuster)
{
	if(!channelCuster)
		return;

	if(channelCuster->name)
		free(channelCuster->name);

	struct Source* pHead= channelCuster->source;
	struct Source* pCur = NULL;

	while(pHead)
	{
		free_source(pHead);

		pCur = pHead->pNext;
		free(pHead);

		pHead = pCur;
	}
}

struct Configure* malloc_configure()
{
	struct Configure* configure = (struct Configure*)malloc(sizeof(struct Configure));

	memset(configure, 0 , sizeof(struct Configure));

	configure->log = NULL;
	configure->channelCount = 0;
	configure->channelCuster = NULL;
}

void free_configure(struct Configure* configure)
{
	if(!configure)
		return;

	if(configure->log)
		free(configure->log);
	configure->channelCount = 0;
	configure->channelCuster = NULL;

	free(configure);
}

struct Configure* createConfigure(char* configure_xml)
{
	xmlNodePtr cur;
	xmlDocPtr doc;

	char xpath[ XPATH_LEN ];
	char *info = NULL;
	struct Outline* last_outline = NULL;
	struct Source* last_source = NULL;

	struct ChannelCuster* channelCuster = NULL;
	struct ChannelCuster* last_channelCuster = NULL;


	doc = xmlParseFile( configure_xml);
    	if ( doc == NULL )
    	{
    		DEBUG_SCREEN("can't load configure log [%s].", configure_xml);
        	return NULL;
    	}

	cur = xmlDocGetRootElement( doc );    
	if ( cur == NULL )
    	{
       		xmlFreeDoc( doc );

		DEBUG_SCREEN("can't load configure log [%s].", configure_xml);
       		return NULL;
    	}

	struct Configure* configure = malloc_configure();

	info = get_locationContent( doc, "//newspaper/log" );
	if(info)
		configure->log = (char*)strdup(info);

	for(int pos = 1;;pos++)
	{
		sprintf( xpath, "//newspaper/channel[%d]", pos);
		cur = get_location( doc, xpath);
		if(cur == NULL)
		{
			break;
		}

		channelCuster = malloc_channelcuster();
		if(configure->channelCuster == NULL)
			configure->channelCuster = channelCuster;
		
		info = ( char* ) xmlGetProp( cur, ( const xmlChar* ) "key" );
		if(!info)
		{
			DEBUG_SCREEN("configure 'key' error.\n");
			free_configure(configure);
			return NULL;
		}
		channelCuster->key = atoi(info);

		sprintf( xpath, "//newspaper/channel[%d]/name", pos);
		info = get_locationContent( doc, xpath );
	   	if(!info)
		{
			DEBUG_SCREEN("configure 'name' error.\n");
			free_configure(configure);
			return NULL;
		}
		channelCuster->name = (char*)strdup(CodeConvert(info, METHOD_UTF8_TO_GB2312));

		sprintf( xpath, "//newspaper/channel[%d]/interval", pos);
		info = get_locationContent( doc, xpath );
	   	if(!info)
		{
			DEBUG_SCREEN("configure 'interval' error.\n");
			free_configure(configure);
			return NULL;
		}
		channelCuster->interval = atoi(info);

		last_source = NULL;
		for(int i = 1;;i++)
		{
			sprintf( xpath, "//newspaper/channel[%d]/source[%d]", pos, i);
			cur = get_location( doc, xpath);
			if(cur == NULL)
				break;
				
			struct Source* source = malloc_source();
			info = (char*)xmlGetProp( cur, ( const xmlChar* ) "name" );
			if(info)
				source->name = (char*)strdup(CodeConvert(info, METHOD_UTF8_TO_GB2312));
			
			info = (char*)xmlGetProp( cur, ( const xmlChar* ) "subkey" );
			if(info)
				source->subkey = atoi(info);
				
			
			last_outline = NULL;
			for(int j=1;;j++)
			{
				sprintf( xpath, "//newspaper/channel[%d]/source[%d]/outline[%d]", pos, i, j);
				cur = get_location( doc, xpath);
				if(cur == NULL)
					break;
	
				struct Outline* outline = malloc_outline();
				
				info = (char*)xmlGetProp( cur, ( const xmlChar* ) "title" );
				if(info)
					outline->title = (char*)strdup(CodeConvert(info, METHOD_UTF8_TO_GB2312));

				info = (char*)xmlGetProp( cur, ( const xmlChar* ) "xmlUrl" );
				if(info)
					outline->xmlUrl = (char*)strdup(info);
	
				info = (char*)xmlGetProp( cur, ( const xmlChar* ) "htmlUrl" );
				if(info)
					outline->htmlUrl = (char*)strdup(info);
	
				info = (char*)xmlGetProp( cur, ( const xmlChar* ) "type" );
				if(info)
					outline->type = (char*)strdup(info);
					
				sprintf( xpath, "//newspaper/channel[%d]/source[%d]/outline[%d]/begintag", pos, i, j);
				info = get_locationContent( doc, xpath );
				if(info)
					outline->begintag = (char*)strdup(info);
				
				sprintf( xpath, "//newspaper/channel[%d]/source[%d]/outline[%d]/endtag", pos, i, j);
				info = get_locationContent( doc, xpath );
				if(info)
					outline->endtag = (char*)strdup(info);
					
				sprintf( xpath, "//newspaper/channel[%d]/source[%d]/outline[%d]/kind", pos, i, j);
				info = get_locationContent( doc, xpath );
				if(info)
					outline->kind = atoi(info);
	
				if(last_outline == NULL)
				{
					source->outline = outline;
					last_outline = outline;
				}else
				{
					last_outline->pNext = outline;
					last_outline = outline;
				}
	
				source->outline_count++;
			}
			
			if(last_source == NULL)
			{
				channelCuster->source = source;
				last_source = source;
			}else
			{
				last_source->pNext = source;
				last_source = source;
			}
			
			channelCuster->source_count++;
		}
		

		if(last_channelCuster == NULL)
			last_channelCuster = channelCuster;
		else
		{
			last_channelCuster->pNext = channelCuster;
			last_channelCuster = channelCuster;
		}

		configure->channelCount++;
	}

	xmlFreeDoc( doc );
	
	return configure;
}

void destroyConfigure(struct Configure* configure)
{
	if(!configure)
		return;

	struct ChannelCuster* pHead = configure->channelCuster;
	struct ChannelCuster* pNext = NULL;

	while(pHead)
	{
		free_channelcuster(pHead);

		pNext = pHead->pNext;
		free(pHead);

		pHead= pHead->pNext;
	}

	free_configure(configure);
}