/*

 * Copyright (C) 2020  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 <glib.h>

#include <expat.h>

#include <razor.h>

#include <plover/plover.h>

#include "pre-inst/post.h"

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

enum post_state {

    POST_STATE_BEGIN,

    POST_STATE_ROOT,

    POST_STATE_ARGUMENT,

    POST_STATE_INSTALL_PREFIX,

    POST_STATE_REPOSITORY,

};

struct post_context {

    struct post *post;

    enum post_state state;

    int unknown_elements;

    GPtrArray *args;

    GString *str;

};

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

{

    struct post_context *ctx=data;

    if (ctx->unknown_elements)

	ctx->unknown_elements++;

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

      !strcmp(name,PLOVER_XML_NS "\xFF" "post"))

	ctx->state=POST_STATE_ROOT;

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

      !strcmp(name,PLOVER_XML_NS "\xFF" "command"))

    {

	ctx->state=POST_STATE_ARGUMENT;

	if (ctx->args->len>0)

	{

	    ctx->str=g_ptr_array_index(ctx->args,0);

	    g_string_truncate(ctx->str,0);

	}

	else

	{

	    ctx->str=g_string_new(NULL);

	    g_ptr_array_add(ctx->args,ctx->str);

	}

    }

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

      !strcmp(name,PLOVER_XML_NS "\xFF" "argument"))

    {

	ctx->state=POST_STATE_ARGUMENT;

	ctx->str=g_string_new(NULL);

	if (ctx->args->len==0)

	    g_ptr_array_add(ctx->args,NULL);

	g_ptr_array_add(ctx->args,ctx->str);

    }

    else if (ctx->state==POST_STATE_ARGUMENT)

    {

	if (!strcmp(name,PLOVER_XML_NS "\xFF" "install-prefix"))

	    ctx->state=POST_STATE_INSTALL_PREFIX;

	else if (!strcmp(name,PLOVER_XML_NS "\xFF" "repository"))

	    ctx->state=POST_STATE_REPOSITORY;

	else

	    ctx->unknown_elements++;

    }

    else

	ctx->unknown_elements++;

}

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

{

    struct post_context *ctx=data;

    if (ctx->unknown_elements)

	ctx->unknown_elements--;

    else

	switch (ctx->state)

	{

	    case POST_STATE_BEGIN:

		g_assert_not_reached();

		break;

	    case POST_STATE_ROOT:

		ctx->state=POST_STATE_BEGIN;

		break;

	    case POST_STATE_ARGUMENT:

		ctx->state=POST_STATE_ROOT;

		break;

	    case POST_STATE_INSTALL_PREFIX:

		if (ctx->post->install_prefix)

		    g_string_append(ctx->str,ctx->post->install_prefix);

		ctx->state=POST_STATE_ARGUMENT;

		break;

	    case POST_STATE_REPOSITORY:

		if (ctx->post->repository)

		    g_string_append(ctx->str,ctx->post->repository);

		ctx->state=POST_STATE_ARGUMENT;

		break;

	}

}

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

{

    struct post_context *ctx=data;

    switch (ctx->state)

    {

	case POST_STATE_ARGUMENT:

	    g_string_append_len(ctx->str,s,len);

	    break;

	default:

	    break;

    }

}

struct post *pre_install_post_new(const char *repository,

  const char *install_prefix)

{

    struct post *post;

    post=g_new0(struct post,1);

    post->repository=g_strdup(repository);

    post->install_prefix=g_strdup(install_prefix);

    return post;

}

void pre_install_post_free(struct post *post)

{

    g_free(post->repository);

    g_free(post->install_prefix);

    g_free(post);

}

gboolean pre_install_post_load_uri(struct post *post,const char *uri,

  GError **error)

{

    int i;

    gboolean retval;

    struct post_context ctx={0,};

    struct razor_error *tmp_error=NULL;

    size_t length;

    void *contents;

    XML_Parser parser;

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

    if (!contents)

    {

	plover_propagate_razor_error(error,tmp_error);

	return FALSE;

    }

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

    ctx.post=post;

    ctx.state=POST_STATE_BEGIN;

    ctx.args=g_ptr_array_new();

    XML_SetUserData(parser,&ctx);

    XML_SetElementHandler(parser,post_start_element,post_end_element);

    XML_SetCharacterDataHandler(parser,post_character_data);

    retval=XML_Parse(parser,contents,length,TRUE)!=XML_STATUS_ERROR;

    if (!retval)

	g_set_error(error,PLOVER_GENERAL_ERROR,PLOVER_GENERAL_ERROR_FAILED,

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

	  XML_ErrorString(XML_GetErrorCode(parser)),

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

    XML_ParserFree(parser);

    razor_uri_free_contents(contents,length);

    if (retval)

    {

	if (ctx.args->len>0 && !g_ptr_array_index(ctx.args,0))

	    g_warning("post: ignoring arguments because no command specified");

	if (post->argv)

	    g_strfreev(post->argv);

	if (ctx.args->len>0 && g_ptr_array_index(ctx.args,0))

	{

	    post->argc=ctx.args->len;

	    post->argv=g_new(gchar *,post->argc+1);

	    for(i=0;i<post->argc;i++)

		post->argv[i]=

		  g_string_free(g_ptr_array_index(ctx.args,i),FALSE);

	    post->argv[i]=NULL;

	}

	else

	{

	    post->argc=0;

	    post->argv=g_new0(gchar *,1);

	}

	g_ptr_array_free(ctx.args,FALSE);

    }

    return retval;

}