#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#ifdef WIN32
#include <io.h>
#endif
#include <fcntl.h>
#include <bl/bl.h>
#include "testcase.h"

GQuark testcase_error_quark(void)
{
    return g_quark_from_static_string("testcase-error-quark");
}

#if !HAVE_MKSTEMP
/*
 * An insecure implementation of mkstemp(), for those platforms that
 * don't support it.
 */
int mkstemp(char *template)
{
    int fd;
    char *s;
    for(;;)
    {
	s=g_strdup(template);
	mktemp(s);
	if (!*s)
	{
	    errno=EEXIST;
	    g_free(s);
	    return -1;
	}
	fd=open(s,O_RDWR|O_CREAT|O_EXCL,0600);
	if (fd>0)
	{
	    strcpy(template,s);
	    g_free(s);
	    return fd;
	}
	else
	    g_free(s);
    }
}
#endif	/* !HAVE_MKSTEMP */

/*
 * As write(), but always convert NL to CR NL.
 */
static size_t write_text(int fd,const char *buf,size_t count,GError **error)
{
    size_t i;
    FILE *fp;
    fd=dup(fd);
    if (fd<0)
	return -1;
#ifdef WIN32
    if (_setmode(fd,_O_BINARY)<0)
    {
	close(fd);
	g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),
	  "Failed to set mode of bookloupe input file to binary: %s",
	  g_strerror(errno));
	return -1;
    }
#endif
    fp=fdopen(fd,"wb");
    if (!fp)
    {
	close(fd);
	g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),
	  "Failed to open stream to bookloupe input file: %s",
	  g_strerror(errno));
	return -1;
    }
    for(i=0;i<count;i++)
    {
	if (buf[i]=='\n')
	    if (putc('\r',fp)==EOF)
	    {
		g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),
		  "Error writing bookloupe input file: %s",g_strerror(errno));
		(void)fclose(fp);
		return -1;
	    }
	if (putc(buf[i],fp)==EOF)
	{
	    g_set_error(error,G_FILE_ERROR,g_file_error_from_errno(errno),
	      "Error writing bookloupe input file: %s",g_strerror(errno));
	    (void)fclose(fp);
	    return -1;
	}
    }
    if (fclose(fp))
    {
	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) or any common prefix between s1 and s2.
 */
size_t common_prefix_length(const char *s1,const char *s2)
{
    size_t i;
    for(i=0;s1[i] && s2[i] && s1[i]==s2[i];i++)
	;
    return i;
}

void print_unexpected(const char *unexpected,gsize differs_at)
{
    int col;
    const char *endp,*bol;
    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=differs_at-(bol-string->str);
    fprintf(stderr,"%s\n%*s^\n",string->str,col,"");
    g_string_free(string,TRUE);
}

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;
    FILE *fp;
    char input[]="TEST-XXXXXX";
    char *command[3];
    char *output,*s;
    GError *tmp_err=NULL;
    if (standard_input)
    {
	if (encoding)
	{
	    s=g_convert(standard_input,-1,encoding,"UTF-8",NULL,&n,&tmp_err);
	    if (!s)
	    {
		g_propagate_prefixed_error(error,tmp_err,
		  "Conversion to %s failed: ",encoding);
		return FALSE;
	    }
	}
	else
	{
	    s=g_strdup(standard_input);
	    n=strlen(s);
	}
    }
    else
    {
	n=0;
	s=NULL;
    }
    fd=mkstemp(input);
    if (n && write_text(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);
}