#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"

#include "testcaseoutput.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);

}

/*

 * Verify that all the output files specified by a testcase are present

 * with the expected contents. 

 */

gboolean testcase_verify_output_files(Testcase *testcase)

{

    GSList *link;

    GError *tmp_err=NULL;

    gboolean retval=TRUE;

    ssize_t offset;

    gchar *contents;

    TestcaseOutput *output;

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

    {

	output=link->data;

	if (!testcase_output_read(testcase,output,&contents,NULL,&tmp_err))

	{

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

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

	    g_clear_error(&tmp_err);

	    retval=FALSE;

	    break;

	}

	else

	{

	    if (strcmp(contents,output->contents))

	    {

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

		offset=common_prefix_length(contents,output->contents);

		if (!offset && !contents[offset])

		    g_print("%s: Unexpected empty output from bookloupe.\n",

		      output->name);

		else

		{

		    g_print("%s: Unexpected output from bookloupe:\n",

		      output->name);

		    print_unexpected(contents,offset);

		}

		retval=FALSE;

	    }

	    g_free(contents);

	    break;

	}

    }

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

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

	{

	    if (retval)

	    {

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

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

		retval=TRUE;

	    }

	    g_clear_error(&tmp_err);

	}

    return retval;

}

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;

}

/*

 * Parse a warning of the form:

 *	[blank line]

 *	<echoed line> (ignored)

 *	"    Line " <number> [" column " <number>] " - " <text> "\n"

 * If not specified, the column is returned as 0.

 * Returns: the number of bytes parsed, or -1 on error.

 */

static ssize_t testcase_parse_warning(Testcase *testcase,const char *output,

  guint *line,guint *column,char **text)

{

    ssize_t offset=0;

    guint64 tmp;

    char *s,*endp;

    if (output[offset]!='\n')

    {

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

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

	print_unexpected(output,offset);

	return -1;

    }

    offset++;

    s=strchr(output+offset,'\n');

    if (!s)

    {

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

	g_print("Missing new-line in output from bookloupe:\n");

	print_unexpected(output,offset);

	return -1;

    }

    offset=s-output+1;

    if (!g_str_has_prefix(output+offset,"    Line "))

    {

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

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

	offset+=common_prefix_length(output+offset,"    Line ");

	print_unexpected(output,offset);

	return -1;

    }

    offset+=9;

    tmp=g_ascii_strtoull(output+offset,&endp,10);

    if (tmp<1 || tmp>G_MAXUINT || tmp==G_MAXUINT64)

    {

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

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

	print_unexpected(output,offset);

	return -1;

    }

    *line=tmp;

    offset=endp-output;

    if (g_str_has_prefix(output+offset," column "))

    {

	offset+=8;

	tmp=g_ascii_strtoull(output+offset,&endp,10);

	if (tmp<1 || tmp>G_MAXUINT || tmp==G_MAXUINT64)

	{

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

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

	    print_unexpected(output,offset);

	    return -1;

	}

	*column=tmp;

	offset=endp-output;

    }

    else

	*column=0;

    if (!g_str_has_prefix(output+offset," - "))

    {

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

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

	offset+=common_prefix_length(output+offset," - ");

	print_unexpected(output,offset);

	return -1;

    }

    offset+=3;

    s=strchr(output+offset,'\n');

    if (!s)

    {

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

	g_print("Missing new-line in output from bookloupe:\n");

	print_unexpected(output,offset);

	return -1;

    }

    *text=g_strndup(output+offset,s-(output+offset));

    return s-output+1;

}

/*

 * Check the summary produced by bookloupe against testcase->summary.

 */

static gboolean testcase_check_summary(Testcase *testcase,const char *summary)

{

    int i;

    gboolean r;

    gchar **lines;

    GSList *texts,*lnk;

    if (!testcase->summary.texts)

	return TRUE;

    texts=g_slist_copy(testcase->summary.texts);

    lines=g_strsplit(summary,"\n",0);

    for(i=0;lines[i];i++)

    {

	if (!g_str_has_prefix(lines[i],"   --> "))

	    continue;

	for(lnk=texts;lnk;lnk=lnk->next)

	    if (!strcmp(lines[i]+7,lnk->data))

	    {

		texts=g_slist_delete_link(texts,lnk);

		break;

	    }

    }

    g_strfreev(lines);

    r=!texts;

    if (texts)

    {

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

	g_print("Missing summary text from bookloupe:\n");

	g_print("   --> %s\n",texts->data);

    }

    g_slist_free(texts);

    return r;

}

/*

 * Check the warnings produced by bookloupe against either the

 * unstructured testcase->expected or the structured testcase->warnings

 * as appropriate.

 */

static gboolean testcase_check_warnings(Testcase *testcase,const char *output,

  char **xfail)

{

    gboolean r=TRUE;

    size_t offset;

    ssize_t off;

    int i,count_false_positive,count_false_negative;

    int total_false_positive,total_false_negative;

    char *text;

    guint *counts,line,column;

    GSList *link,*link2;

    TestcaseWarning *warning;

    TestcaseLocation *location;

    *xfail=NULL;

    if (testcase->expected)

    {

	if (strcmp(output,testcase->expected))

	{

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

	    offset=common_prefix_length(output,testcase->expected);

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

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

	    else

	    {

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

		print_unexpected(output,offset);

	    }

	    return FALSE;

	}

	return TRUE;

    }

    counts=g_new0(guint,g_slist_length(testcase->warnings));

    for(offset=0;output[offset];)

    {

	off=testcase_parse_warning(testcase,output+offset,&line,&column,&text);

	if (off<0)

	{

	    r=FALSE;

	    break;

	}

	offset+=off;

	for(link=testcase->warnings,i=0;link;link=link->next,i++)

	{

	    warning=link->data;

	    if (strcmp(warning->text,text))

		continue;

	    for(link2=warning->locations;link2;link2=link2->next)

	    {

		location=link2->data;

		if (location->line!=line || location->column!=column)

		    continue;

		counts[i]++;

		break;

	    }

	    if (link2)

		break;

	}

	if (!link)

	{

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

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

	    if (column)

		g_print("    Line %u column %u - %s\n",line,column,text);

	    else

		g_print("    Line %u - %s\n",line,text);

	    r=FALSE;

	    g_free(text);

	    break;

	}

	g_free(text);

    }

    count_false_positive=total_false_positive=0;

    count_false_negative=total_false_negative=0;

    for(link=testcase->warnings,i=0;r && link;link=link->next,i++)

    {

	warning=link->data;

	if (!counts[i] && warning->is_real && !warning->xfail)

	{

	    location=warning->locations->data;

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

	    g_print("Missing warning from bookloupe:\n");

	    if (location->column)

		g_print("    Line %u column %u - %s\n",location->line,

		  location->column,warning->text);

	    else

		g_print("    Line %u - %s\n",location->line,warning->text);

	    r=FALSE;

	    break;

	}

	else if (warning->xfail)

	{

	    if (warning->is_real)

	    {

		total_false_negative++;

		if (!counts[i])

		    count_false_negative++;

	    }

	    else if (!warning->is_real)

	    {

		total_false_positive++;

		if (counts[i])

		    count_false_positive++;

	    }

	}

    }

    g_free(counts);

    if (count_false_positive && count_false_negative)

	*xfail=g_strdup_printf(

	  "with %d of %d false positives and %d of %d false negatives",

	  count_false_positive,total_false_positive,

	  count_false_negative,total_false_negative);

    else if (count_false_positive)

	*xfail=g_strdup_printf("with %d of %d false positives",

	  count_false_positive,total_false_positive);

    else if (count_false_negative)

	*xfail=g_strdup_printf("with %d of %d false negatives",

	  count_false_negative,total_false_negative);

    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;

    char *filename,*s,*summary,*xfail=NULL;

    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;

    }

    r=testcase_spawn_bookloupe(testcase,&testcase->test_output,&error);

    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 || testcase->warnings)

    {

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

	g_string_append(header,filename);

	g_string_append(header,"\n");

	if (!g_str_has_prefix(testcase->test_output,header->str))

	{

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

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

	    offset=common_prefix_length(testcase->test_output,header->str);

	    print_unexpected(testcase->test_output,offset);

	    r=FALSE;

	}

	summary=testcase->test_output+header->len;

	pos=header->len;

	if (r)

	{

	    /* Find the end of the summary */

	    s=strstr(summary,"\n\n");

	    if (s)

	    {

		summary=g_strndup(summary,s-summary);

		r=testcase_check_summary(testcase,summary);

		g_free(summary);

		pos=s-testcase->test_output+2;

	    }

	    else

	    {

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

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

		r=FALSE;

	    }

	}

	g_string_free(header,TRUE);

	if (r)

	    r=testcase_check_warnings(testcase,testcase->test_output+pos,

	      &xfail);

    }

    if (!testcase_verify_output_files(testcase))

	r=FALSE;

    g_free(filename);

    if (r)

    {

	if (xfail)

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

	else

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

    }

    g_free(xfail);

    return r;

}

/*

 * Run a testcase, returning FALSE on error.

 * Bookloupe's output or a suitable error message will be shown.

 */

gboolean testcase_show_output(Testcase *testcase)

{

    gboolean r;

    gchar *output;

    GError *error=NULL;

    r=testcase_create_input_files(testcase,&error);

    if (r)

    {

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

	r&=testcase_remove_input_files(testcase,&error);

    }

    if (r)

	g_print("%s",output);

    else

    {

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

	g_error_free(error);

    }

    return r;

}

/*

 * Free a testcase warning.

 */

void testcase_warning_free(TestcaseWarning *warning)

{

    g_slist_foreach(warning->locations,(GFunc)g_free,NULL);

    g_slist_free(warning->locations);

    g_free(warning->text);

    g_free(warning);

}

/*

 * 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_slist_foreach(testcase->warnings,(GFunc)testcase_warning_free,NULL);

    g_slist_free(testcase->warnings);

    g_free(testcase->encoding);

    g_strfreev(testcase->options);

    g_free(testcase->test_output);

    g_free(testcase);

}