#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <errno.h>

#include <bl/bl.h>

#include "testcase.h"

GQuark testcase_error_quark(void)

{

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

}

/*

 * As write(), but with error handling.

 */

static size_t write_file(int fd,const char *buf,size_t count,GError **error)

{

    if (write(fd,buf,count)<count)

    {

	g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),

	  "Error writing bookloupe input file: %s",g_strerror(errno));

	return -1;

    }

    return count;

}

/*

 * 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++;

    }

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

    g_string_free(string,TRUE);

}

/*

 * Replace \n with \r\n and U+240A (visible symbol for LF) with \n

 */

char *unix2dos(const char *text)

{

    gunichar c;

    const gunichar visible_lf=0x240A;

    GString *string;

    string=g_string_new(NULL);

    while(*text)

    {

	c=g_utf8_get_char(text);

	text=g_utf8_next_char(text);

	if (c=='\n')

	    g_string_append(string,"\r\n");

	else if (c==visible_lf)

	    g_string_append_c(string,'\n');

	else

	    g_string_append_unichar(string,c);

    }

    return g_string_free(string,FALSE);

}

gboolean spawn_bootloupe(const char *encoding,const char *standard_input,

  char **standard_output,char **filename,GError **error)

{

    gboolean r;

    int fd,exit_status;

    size_t n,pos,offset;

    char input[]="TEST-XXXXXX";

    char *command[3];

    char *output,*s,*t;

    GError *tmp_err=NULL;

    if (standard_input)

    {

	if (encoding)

	{

	    t=unix2dos(standard_input);

	    s=g_convert(t,-1,encoding,"UTF-8",NULL,&n,&tmp_err);

	    g_free(t);

	    if (!s)

	    {

		g_propagate_prefixed_error(error,tmp_err,

		  "Conversion to %s failed: ",encoding);

		return FALSE;

	    }

	}

	else

	{

	    s=unix2dos(standard_input);

	    n=strlen(s);

	}

    }

    else

    {

	n=0;

	s=NULL;

    }

    fd=g_mkstemp(input);

    if (n && write_file(fd,s,n,error)!=n)

    {

	g_free(s);

	close(fd);

	(void)remove(input);

	return FALSE;

    }

    g_free(s);

    close(fd);

    command[0]=getenv("BOOKLOUPE");

    if (!command[0])

	command[0]="." G_DIR_SEPARATOR_S "bookloupe";

    command[1]=input;

    command[2]=NULL;

    if (standard_output)

    {

	r=spawn_sync(command,&s,&exit_status,error);

	if (r)

	{

	    if (encoding)

	    {

		output=g_convert(s,-1,"UTF-8",encoding,NULL,NULL,&tmp_err);

		g_free(s);

		if (!output)

		{

		    g_propagate_prefixed_error(error,tmp_err,

		      "Conversion from %s failed: ",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(command,NULL,&exit_status,error);

	output=NULL;

    }

    (void)remove(input);

    if (r && exit_status)

    {

	g_set_error(error,TESTCASE_ERROR,TESTCASE_ERROR_FAILED,

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

	r=FALSE;

    }

    if (r && filename)

	*filename=g_strdup(input);

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

	r=spawn_bootloupe(testcase->encoding,testcase->input,&output,&filename,

	  &error);

    else

    {

	r=spawn_bootloupe(testcase->encoding,testcase->input,NULL,NULL,&error);

        output=filename=NULL;

    }

    if (!r)

    {

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

	fprintf(stderr,"%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))

	{

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

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

	    fprintf(stderr,"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

	    {

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

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

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

		  output+pos);

		r=FALSE;

	    }

	}

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

	{

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

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

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

		fprintf(stderr,"Unexpected zero warnings from bookloupe.\n");

	    else

	    {

		fprintf(stderr,"Unexpected output from bookloupe:\n");

		print_unexpected(output+pos,offset);

	    }

	    r=FALSE;

	}

	g_string_free(header,TRUE);

	g_string_free(expected,TRUE);

    }

    g_free(output);

    g_free(filename);

    if (r)

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

    return r;

}

/*

 * Free a testcase.

 */

void testcase_free(Testcase *testcase)

{

    g_free(testcase->basename);

    g_free(testcase->input);

    g_free(testcase->expected);

    g_free(testcase->encoding);

    g_free(testcase);

}