/*

 * Copyright (C) 2008  Kristian Høgsberg <krh@redhat.com>

 * Copyright (C) 2008  Red Hat, Inc

 * Copyright (C) 2009  J. Ali Harlow <ali@juiblex.co.uk>

 *

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

 * it under the terms of the GNU 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 General Public License along

 * with this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#include <string.h>

#include <stdio.h>

#include <errno.h>

#include <expat.h>

#include <assert.h>

#include "plover/plover.h"

/* Parse a comps.xml package group file. */

static struct comps_requirement *comps_package_requirement_new(void)

{

    struct comps_requirement *req;

    req=calloc(sizeof(*req),1);

    assert(req != NULL);

    req->type=COMPS_REQUIREMENT_OPTIONAL;

    return req;

}

static void comps_package_requirement_free_1(struct comps_requirement *req)

{

    if (req)

    {

	free(req->requires);

	free(req->name);

	free(req);

    }

}

static void comps_package_requirement_free(struct comps_requirement *req)

{

    struct comps_requirement *next;

    while(req)

    {

	next=req->next;

	comps_package_requirement_free_1(req);

	req=next;

    }

}

struct comps_group *comps_group_new(void)

{

    struct comps_group *group;

    group=calloc(sizeof(*group),1);

    assert(group != NULL);

    group->bydefault=1;

    group->uservisible=1;

    return group;

}

static void comps_group_free_1(struct comps_group *group)

{

    if (group)

    {

	free(group->id);

	free(group->name);

	free(group->description);

	comps_package_requirement_free(group->packages);

	free(group);

    }

}

static void comps_group_free(struct comps_group *group)

{

    struct comps_group *next;

    while(group)

    {

	next=group->next;

	comps_group_free_1(group);

	group=next;

    }

}

struct comps *plover_comps_new(void)

{

    struct comps *comps;

    comps=calloc(sizeof(*comps),1);

    assert(comps != NULL);

    return comps;

}

void plover_comps_free(struct comps *comps)

{

    if (comps)

    {

	free(comps->vendor);

	comps_group_free(comps->groups);

	free(comps);

    }

}

enum comps_state {

    COMPS_STATE_BEGIN,

    COMPS_STATE_ROOT,

    COMPS_STATE_GROUP,

    COMPS_STATE_GROUP_ID,

    COMPS_STATE_GROUP_NAME,

    COMPS_STATE_GROUP_DESCRIPTION,

    COMPS_STATE_GROUP_DEFAULT,

    COMPS_STATE_GROUP_USERVISIBLE,

    COMPS_STATE_GROUP_PACKAGELIST,

    COMPS_STATE_GROUP_PACKAGELIST_REQ,

};

struct comps_context {

    XML_Parser parser;

    enum comps_state state;

    int unknown_elements;

    char *vendor;

    struct comps_group *group;

    void *p;

};

static enum comps_requirement_type comps_to_requirement_type(const char *flags)

{

    if (strcmp(flags, "conditional") == 0)

	return COMPS_REQUIREMENT_CONDITIONAL;

    else if (strcmp(flags, "mandatory") == 0)

	return COMPS_REQUIREMENT_MANDATORY;

    else if (strcmp(flags, "default") == 0)

	return COMPS_REQUIREMENT_DEFAULT;

    else

	return COMPS_REQUIREMENT_OPTIONAL;

}

static void comps_start_element(void *data,const char *name,const char **atts)

{

    struct comps_context *ctx = data;

    struct comps_group *group;

    struct comps_requirement *packages;

    int i;

#if 0

    fprintf(stderr,"Starting element '");

    switch(ctx->state)

    {

	case COMPS_STATE_BEGIN:

	    fprintf(stderr,"/");

	    break;

	case COMPS_STATE_ROOT:

	    fprintf(stderr,"/comps/");

	    break;

	case COMPS_STATE_GROUP:

	    fprintf(stderr,"/comps/group/");

	    break;

	case COMPS_STATE_GROUP_ID:

	    fprintf(stderr,"/comps/group/id/");

	    break;

	case COMPS_STATE_GROUP_NAME:

	    fprintf(stderr,"/comps/group/name/");

	    break;

	case COMPS_STATE_GROUP_DESCRIPTION:

	    fprintf(stderr,"/comps/group/description/");

	    break;

	case COMPS_STATE_GROUP_DEFAULT:

	    fprintf(stderr,"/comps/group/default/");

	    break;

	case COMPS_STATE_GROUP_USERVISIBLE:

	    fprintf(stderr,"/comps/group/uservisible/");

	    break;

	case COMPS_STATE_GROUP_PACKAGELIST:

	    fprintf(stderr,"/comps/group/packagelist/");

	    break;

	case COMPS_STATE_GROUP_PACKAGELIST_REQ:

	    fprintf(stderr,"/comps/group/packagelist/packagereq/");

	    break;

    }

    for(i=0;i<ctx->unknown_elements;i++)

	fprintf(stderr,"*/");

    fprintf(stderr,"%s'\n",name);

#endif

    if (ctx->unknown_elements)

	ctx->unknown_elements++;

    else if (ctx->state==COMPS_STATE_BEGIN && !strcmp(name,"comps"))

    {

	ctx->state=COMPS_STATE_ROOT;

	for (i=0;atts[i];i+=2)

	{

	    if (!strcmp(atts[i],

	      "http://project.juiblex.co.uk/plover/ns/2009\xFFvendor"))

		ctx->vendor=strdup(atts[i+1]);

	}

    }

    else if (ctx->state==COMPS_STATE_ROOT && !strcmp(name,"group"))

    {

	ctx->state=COMPS_STATE_GROUP;

	group=comps_group_new();

	group->next=ctx->group;

	ctx->group=group;

    }

    else if (ctx->state==COMPS_STATE_GROUP && !strcmp(name,"id"))

    {

	ctx->state=COMPS_STATE_GROUP_ID;

	ctx->p=&ctx->group->id;

    }

    else if (ctx->state==COMPS_STATE_GROUP && !strcmp(name,"name"))

    {

	ctx->state=COMPS_STATE_GROUP_NAME;

	ctx->p=&ctx->group->name;

    }

    else if (ctx->state==COMPS_STATE_GROUP && !strcmp(name,"description"))

    {

	ctx->state=COMPS_STATE_GROUP_DESCRIPTION;

	ctx->p=&ctx->group->description;

    }

    else if (ctx->state==COMPS_STATE_GROUP && !strcmp(name,"default"))

    {

	ctx->state=COMPS_STATE_GROUP_DEFAULT;

	ctx->p=&ctx->group->bydefault;

    }

    else if (ctx->state==COMPS_STATE_GROUP && !strcmp(name,"uservisible"))

    {

	ctx->state=COMPS_STATE_GROUP_USERVISIBLE;

	ctx->p=&ctx->group->uservisible;

    }

    else if (ctx->state==COMPS_STATE_GROUP && !strcmp(name,"packagelist"))

	ctx->state=COMPS_STATE_GROUP_PACKAGELIST;

    else if (ctx->state==COMPS_STATE_GROUP_PACKAGELIST &&

      !strcmp(name,"packagereq"))

    {

	packages=comps_package_requirement_new();

	packages->next=ctx->group->packages;

	ctx->group->packages=packages;

	for (i=0;atts[i];i+=2)

	{

	    if (!strcmp(atts[i],"type"))

		packages->type=comps_to_requirement_type(atts[i+1]);

	    else if (!strcmp(atts[i],"requires"))

	    {

		packages->requires=strdup(atts[i+1]);

		packages->type=COMPS_REQUIREMENT_CONDITIONAL;

	    }

	}

	ctx->state=COMPS_STATE_GROUP_PACKAGELIST_REQ;

	ctx->p=&packages->name;

    }

    else

	ctx->unknown_elements++;

}

struct comps_list

{

    struct comps_list *next;

    /* body */

};

void *comps_list_reverse(void *list)

{

    struct comps_list *link=list,*prev=NULL,*next;

    while(link)

    {

	next=link->next;

	link->next=prev;

	prev=link;

	link=next;

    }

    return prev;

}

static void comps_end_element(void *data,const char *name)

{

    struct comps_context *ctx=data;

    if (ctx->unknown_elements)

	ctx->unknown_elements--;

    else

	switch (ctx->state)

	{

	    case COMPS_STATE_ROOT:

		ctx->group=comps_list_reverse(ctx->group);

		ctx->state=COMPS_STATE_BEGIN;

		break;

	    case COMPS_STATE_GROUP:

		ctx->group->packages=comps_list_reverse(ctx->group->packages);

		ctx->state=COMPS_STATE_ROOT;

		break;

	    case COMPS_STATE_GROUP_ID:

	    case COMPS_STATE_GROUP_NAME:

	    case COMPS_STATE_GROUP_DESCRIPTION:

	    case COMPS_STATE_GROUP_DEFAULT:

	    case COMPS_STATE_GROUP_USERVISIBLE:

	    case COMPS_STATE_GROUP_PACKAGELIST:

		ctx->state=COMPS_STATE_GROUP;

		break;

	    case COMPS_STATE_GROUP_PACKAGELIST_REQ:

		ctx->state=COMPS_STATE_GROUP_PACKAGELIST;

		break;

	}

#if 0

    fprintf(stderr,"Ending element '");

    switch(ctx->state)

    {

	case COMPS_STATE_BEGIN:

	    fprintf(stderr,"/");

	    break;

	case COMPS_STATE_ROOT:

	    fprintf(stderr,"/comps/");

	    break;

	case COMPS_STATE_GROUP:

	    fprintf(stderr,"/comps/group/");

	    break;

	case COMPS_STATE_GROUP_ID:

	    fprintf(stderr,"/comps/group/id/");

	    break;

	case COMPS_STATE_GROUP_NAME:

	    fprintf(stderr,"/comps/group/name/");

	    break;

	case COMPS_STATE_GROUP_DESCRIPTION:

	    fprintf(stderr,"/comps/group/description/");

	    break;

	case COMPS_STATE_GROUP_DEFAULT:

	    fprintf(stderr,"/comps/group/default/");

	    break;

	case COMPS_STATE_GROUP_USERVISIBLE:

	    fprintf(stderr,"/comps/group/uservisible/");

	    break;

	case COMPS_STATE_GROUP_PACKAGELIST:

	    fprintf(stderr,"/comps/group/packagelist/");

	    break;

	case COMPS_STATE_GROUP_PACKAGELIST_REQ:

	    fprintf(stderr,"/comps/group/packagelist/packagereq/");

	    break;

    }

    {

	int i;

	for(i=0;i<ctx->unknown_elements;i++)

	    fprintf(stderr,"*/");

    }

    fprintf(stderr,"%s'\n",name);

#endif

}

static void comps_character_data(void *data,const XML_Char *s,int len)

{

    struct comps_context *ctx=data;

    char *str;

    switch (ctx->state)

    {

	case COMPS_STATE_GROUP_ID:

	case COMPS_STATE_GROUP_NAME:

	case COMPS_STATE_GROUP_DESCRIPTION:

	case COMPS_STATE_GROUP_PACKAGELIST_REQ:

	    *(char **)ctx->p=str=malloc(len+1);

	    memcpy(str,s,len);

	    str[len]='\0';

	    break;

	case COMPS_STATE_GROUP_DEFAULT:

	case COMPS_STATE_GROUP_USERVISIBLE:

	    *(int *)ctx->p=*s=='T'||*s=='t';

	    break;

    }

}

#define XML_BUFFER_SIZE 4096

struct comps *plover_comps_new_from_file(const char *filename)

{

    struct comps_context ctx={0};

    void *buf;

    int len;

    FILE *fp;

    XML_ParsingStatus status;

    struct comps *comps;

    fp=fopen(filename,"r");

    if (!fp)

	return NULL;

    ctx.state=COMPS_STATE_BEGIN;

    ctx.parser=XML_ParserCreateNS(NULL,'\xFF');

    XML_SetUserData(ctx.parser,&ctx);

    XML_SetElementHandler(ctx.parser,comps_start_element,comps_end_element);

    XML_SetCharacterDataHandler(ctx.parser,comps_character_data);

    do

    {

	XML_GetParsingStatus(ctx.parser,&status);

	switch (status.parsing)

	{

	    case XML_SUSPENDED:

		XML_ResumeParser(ctx.parser);

		break;

	    case XML_PARSING:

	    case XML_INITIALIZED:

		buf=XML_GetBuffer(ctx.parser,XML_BUFFER_SIZE);

		len=fread(buf,1,XML_BUFFER_SIZE,fp);

		if (len<0)

		{

		    comps_group_free(ctx.group);

		    XML_ParserFree(ctx.parser);

		    fclose(fp);

		    return NULL;

		}

		if (!XML_ParseBuffer(ctx.parser,len,!len))

		{

		    comps_group_free(ctx.group);

		    XML_ParserFree(ctx.parser);

		    fclose(fp);

		    return NULL;

		}

		break;

	    case XML_FINISHED:

		break;

	}

    } while (status.parsing!=XML_FINISHED);

    XML_ParserFree(ctx.parser);

    fclose(fp);

    comps=plover_comps_new();

    comps->vendor=ctx.vendor;

    comps->groups=ctx.group;

    return comps;

}

struct comps_group *plover_comps_lookup_group(struct comps *comps,

  const char *id)

{

    struct comps_group *group;

    for(group=comps->groups;group;group=group->next)

	if (!strcmp(group->id,id))

	    return group;

    return NULL;

}