/*

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

 * Copyright (C) 2008  Red Hat, Inc

 * Copyright (C) 2009, 2016  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 "config.h"

#include <string.h>

#include <stdio.h>

#include <errno.h>

#include <expat.h>

#include <assert.h>

#include "plover/plover.h"

#include "plover/uri-handler.h"

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

#define PLOVER_XML_NS "http://project.juiblex.co.uk/plover/ns/2009"

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;

    }

}

static 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);

	free(comps->distribution);

	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,*distribution;

    enum comps_database_setting database;

    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],PLOVER_XML_NS "\xFF" "vendor"))

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

	    else if (!strcmp(atts[i],PLOVER_XML_NS "\xFF" "distribution"))

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

	    else if (!strcmp(atts[i],PLOVER_XML_NS "\xFF" "database"))

	    {

		if (!g_strcmp0(atts[i+1],"distribution-local"))

		    ctx->database=COMPS_DATABASE_DISTRIBUTION_LOCAL;

		else

		    ctx->database=COMPS_DATABASE_GLOBAL;

	    }

	}

    }

    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_BEGIN:

		g_assert_not_reached();

		break;

	    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_BEGIN:

	case COMPS_STATE_ROOT:

	case COMPS_STATE_GROUP:

	case COMPS_STATE_GROUP_PACKAGELIST:

	    break;

	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;

    }

}

struct comps *plover_comps_new_from_uri(const char *uri,GError **error)

{

    struct comps_context ctx={0};

    struct razor_error *tmp_error=NULL;

    void *contents;

    size_t length;

    struct comps *comps;

    g_return_val_if_fail(plover__uri_validate(uri),NULL);

    plover__uri_handler_init();

    contents=razor_uri_get_contents(uri,&length,FALSE,&tmp_error);

    if (!contents)

    {

	plover_propagate_razor_error(error,tmp_error);

	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);

    if (XML_Parse(ctx.parser,contents,length,TRUE)==XML_STATUS_ERROR)

    {

	g_set_error(error,PLOVER_GENERAL_ERROR,PLOVER_GENERAL_ERROR_FAILED,

	  "%s on line %lu of '%s'\n",

	  XML_ErrorString(XML_GetErrorCode(ctx.parser)),

	  (unsigned long)XML_GetCurrentLineNumber(ctx.parser),uri);

	XML_ParserFree(ctx.parser);

	razor_uri_free_contents(contents,length);

	return NULL;

    }

    XML_ParserFree(ctx.parser);

    razor_uri_free_contents(contents,length);

    comps=plover_comps_new();

    comps->vendor=ctx.vendor;

    comps->distribution=ctx.distribution;

    comps->database=ctx.database;

    if (comps->database==COMPS_DATABASE_DISTRIBUTION_LOCAL &&

      (!comps->vendor || !comps->distribution))

    {

	g_warning("%s: database setting of distribution-local ignored",uri);

	comps->database=COMPS_DATABASE_GLOBAL;

    }

    comps->groups=ctx.group;

    return comps;

}

struct comps *plover_comps_new_from_file(const char *filename)

{

    gchar *uri;

    GFile *file;

    struct comps *comps;

    file=g_file_new_for_path(filename);

    uri=g_file_get_uri(file);

    g_object_unref(file);

    comps=plover_comps_new_from_uri(uri,NULL);

    g_free(uri);

    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;

}

void plover_comps_set_vendor(struct comps *comps,const char *vendor)

{

    free(comps->vendor);

    comps->vendor=strdup(vendor);

}

void plover_comps_set_distribution(struct comps *comps,const char *distribution)

{

    free(comps->distribution);

    comps->distribution=strdup(distribution);

}