#include <stdlib.h>

 #include <stdio.h>

 #include <string.h>

 #include <errno.h>

 #include <glib.h>

 #include <glib/gstdio.h>

 #include <bl/bl.h>

 #include "testcase.h"

 #include "testcaseinput.h"

 GQuark testcase_error_quark(void)

 {

     return g_quark_from_static_string("testcase-error-quark");

 }

 /*

  * Return the length (in bytes) of any common prefix between s1 and s2.

  * The returned length will always represent an exact number of characters.

  */

 size_t common_prefix_length(const char *s1,const char *s2)

 {

     gunichar c1,c2;

     const char *s=s1;

     while(*s1 && *s2)

     {

 	c1=g_utf8_get_char(s1);

 	c2=g_utf8_get_char(s2);

 	if (c1!=c2)

 	    break;

 	s1=g_utf8_next_char(s1);

 	s2=g_utf8_next_char(s2);

     }

     return s1-s;

 }

 void print_unexpected(const char *unexpected,gsize differs_at)

 {

     int col;

     gunichar c;

     const char *endp,*bol,*s;

     GString *string;

     endp=strchr(unexpected+differs_at,'\n');

     if (!endp)

 	endp=unexpected+strlen(unexpected);

     string=g_string_new_len(unexpected,endp-unexpected);

     bol=strrchr(string->str,'\n');

     if (bol)

 	bol++;

     else

 	bol=string->str;

     col=0;

     s=bol;

     endp=string->str+differs_at;

     while(s<endp)

     {

 	c=g_utf8_get_char(s);

 	s=g_utf8_next_char(s);

 	if (c=='\t')

 	    col=(col&~7)+8;

 	else if (g_unichar_iswide(c))

 	    col+=2;

 	else if (!g_unichar_iszerowidth(c))

 	    col++;

     }

     g_print("%s\n%*s^\n",string->str,col,"");

     g_string_free(string,TRUE);

 }

 /*

  * Create all the input files needed by a testcase and, if required,

  * a temporary directory in which to store them.

  */

 gboolean testcase_create_input_files(Testcase *testcase,GError **error)

 {

     GSList *link,*link2;

     if (testcase->flags&TESTCASE_TMP_DIR)

     {

 	testcase->tmpdir=g_strdup("TEST-XXXXXX");

 	if (!g_mkdtemp(testcase->tmpdir))

 	{

 	    g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),

 	      "Failed to create temporary directory: %s",g_strerror(errno));

 	    g_free(testcase->tmpdir);

 	    testcase->tmpdir=NULL;

 	    return FALSE;

 	}

     }

     for(link=testcase->inputs;link;link=link->next)

 	if (!testcase_input_create(testcase,link->data,error))

 	{

 	    for(link2=testcase->inputs;link2!=link;link2=link2->next)

 		(void)testcase_input_remove(testcase,link2->data,NULL);

 	    if (testcase->tmpdir)

 	    {

 		(void)g_rmdir(testcase->tmpdir);

 		g_free(testcase->tmpdir);

 		testcase->tmpdir=NULL;

 	    }

 	    return FALSE;

 	}

     return TRUE;

 }

 /*

  * Remove all the input files used by a testcase and, if created,

  * the temporary directory in which they are stored.

  */

 gboolean testcase_remove_input_files(Testcase *testcase,GError **error)

 {

     GSList *link;

     GError *tmp_err=NULL;

     gboolean retval=TRUE;

     for(link=testcase->inputs;link;link=link->next)

 	if (!testcase_input_remove(testcase,link->data,&tmp_err))

 	{

 	    if (error && !*error)

 		g_propagate_error(error,tmp_err);

 	    else

 		g_clear_error(&tmp_err);

 	    retval=FALSE;

 	}

     if (testcase->tmpdir)

     {

 	if (g_rmdir(testcase->tmpdir))

 	{

 	    if (error && !*error)

 		g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),

 		  "Failed to remove temporary directory: %s",g_strerror(errno));

 	    retval=FALSE;

 	}

 	g_free(testcase->tmpdir);

 	testcase->tmpdir=NULL;

     }

     return retval;

 }

 /*

  * Replace every occurance of an input file name in <str> with the

  * filename which holds that input. For input files with fixed names,

  * this is a noop. For input files which use the "XXXXXX" sequence

  * to create a unique filename, the XXXXXX will be replaced with the

  * 6 characters that were chosen to be unique.

  */

 char *testcase_resolve_input_files(Testcase *testcase,const char *str)

 {

     GSList *link;

     gsize offset,pos;

     char *s;

     TestcaseInput *input;

     GString *filename=g_string_new(str);

     for(link=testcase->inputs;link;link=link->next)

     {

 	input=link->data;

 	if (!input->name_used)

 	{

 	    g_warning("%s: Input file uninstantiated",input->name);

 	    continue;

 	}

 	offset=0;

 	do

 	{

 	    s=strstr(filename->str+offset,input->name);

 	    if (s)

 	    {

 		pos=s-filename->str;

 		g_string_overwrite(filename,pos,input->name_used);

 		offset=pos+strlen(input->name);

 	    }

 	} while(s);

     }

     return g_string_free(filename,FALSE);

 }

 gboolean testcase_spawn_bookloupe(Testcase *testcase,char **standard_output,

   GError **error)

 {

     gboolean r;

     int i,exit_status;

     char **argv;

     char *output,*s;

     GError *tmp_err=NULL;

     if (testcase->options)

 	argv=g_new(char *,g_strv_length(testcase->options)+3);

     else

 	argv=g_new(char *,3);

     s=getenv("BOOKLOUPE");

     if (!s)

 	s="bookloupe";

     argv[0]=path_to_absolute(s);

     for(i=0;testcase->options && testcase->options[i];i++)

 	argv[i+1]=testcase_resolve_input_files(testcase,testcase->options[i]);

     argv[i+1]=testcase_resolve_input_files(testcase,"TEST-XXXXXX");

     argv[i+2]=NULL;

     if (standard_output)

     {

 	r=spawn_sync(testcase->tmpdir,argv,&s,&exit_status,error);

 	if (r)

 	{

 	    if (testcase->encoding)

 	    {

 		output=g_convert(s,-1,"UTF-8",testcase->encoding,NULL,NULL,

 		  &tmp_err);

 		g_free(s);

 		if (!output)

 		{

 		    g_propagate_prefixed_error(error,tmp_err,

 		      "Conversion from %s failed: ",testcase->encoding);

 		    r=FALSE;

 		}

 	    }

 	    else

 	    {

 		output=s;

 		if (!g_utf8_validate(s,-1,NULL))

 		{

 		    g_set_error_literal(error,TESTCASE_ERROR,

 		      TESTCASE_ERROR_FAILED,

 		      "bookloupe output is not valid UTF-8");

 		    r=FALSE;

 		}

 	    }

 	}

     }

     else

     {

 	r=spawn_sync(testcase->tmpdir,argv,NULL,&exit_status,error);

 	output=NULL;

     }

     g_strfreev(argv);

     if (r && exit_status)

     {

 	g_set_error(error,TESTCASE_ERROR,TESTCASE_ERROR_FAILED,

 	  "bookloupe exited with code %d",exit_status);

 	r=FALSE;

     }

     if (r && standard_output)

 	*standard_output=output;

     return r;

 }

 /*

  * Run a testcase, returning FALSE on fail or error and

  * TRUE on pass or expected-fail.

  * Suitable message(s) will be printed in all cases.

  */

 gboolean testcase_run(Testcase *testcase)

 {

     gboolean r;

     size_t pos,offset;

     GString *header,*expected;

     char *output,*filename,*s;

     GError *error=NULL;

     if (!testcase_create_input_files(testcase,&error))

     {

 	g_print("%s: FAIL\n",testcase->basename);

 	g_print("%s\n",error->message);

 	g_error_free(error);

 	return FALSE;

     }

     if (testcase->expected)

 	r=testcase_spawn_bookloupe(testcase,&output,&error);

     else

     {

 	r=testcase_spawn_bookloupe(testcase,NULL,&error);

         output=NULL;

     }

     if (!r)

     {

 	g_print("%s: FAIL\n",testcase->basename);

 	g_print("%s\n",error->message);

 	g_error_free(error);

 	(void)testcase_remove_input_files(testcase,NULL);

 	return FALSE;

     }

     filename=testcase_resolve_input_files(testcase,"TEST-XXXXXX");

     if (!testcase_remove_input_files(testcase,&error))

     {

 	g_print("%s: FAIL\n",testcase->basename);

 	g_print("%s\n",error->message);

 	g_error_free(error);

 	return FALSE;

     }

     if (testcase->expected)

     {

 	header=g_string_new("\n\nFile: ");

 	g_string_append(header,filename);

 	g_string_append(header,"\n");

 	expected=g_string_new(testcase->expected);

 	if (!g_str_has_prefix(output,header->str))

 	{

 	    g_print("%s: FAIL\n",testcase->basename);

 	    offset=common_prefix_length(output,header->str);

 	    g_print("Unexpected header from bookloupe:\n");

 	    print_unexpected(output,offset);

 	    r=FALSE;

 	}

 	pos=header->len;

 	if (r)

 	{

 	    /* Skip the summary */

 	    s=strstr(output+pos,"\n\n");

 	    if (s)

 		pos=s-output+2;

 	    else

 	    {

 		g_print("%s: FAIL\n",testcase->basename);

 		offset=common_prefix_length(output,header->str);

 		g_print("Unterminated summary from bookloupe:\n%s\n",

 		  output+pos);

 		r=FALSE;

 	    }

 	}

 	if (r && strcmp(output+pos,expected->str))

 	{

 	    g_print("%s: FAIL\n",testcase->basename);

 	    offset=common_prefix_length(output+pos,expected->str);

 	    if (!offset && !output[pos+offset])

 		g_print("Unexpected zero warnings from bookloupe.\n");

 	    else

 	    {

 		g_print("Unexpected output from bookloupe:\n");

 		print_unexpected(output+pos,offset);

 	    }

 	    r=FALSE;

 	}

 	g_string_free(header,TRUE);

 	g_string_free(expected,TRUE);

     }

     g_free(filename);

     g_free(output);

     if (r)

 	g_print("%s: PASS\n",testcase->basename);

     return r;

 }

 /*

  * Free a testcase.

  */

 void testcase_free(Testcase *testcase)

 {

     g_free(testcase->basename);

     g_slist_foreach(testcase->inputs,(GFunc)testcase_input_free,NULL);

     g_slist_free(testcase->inputs);

     g_free(testcase->expected);

     g_free(testcase->encoding);

     g_strfreev(testcase->options);

     g_free(testcase);

 }