/*

 * Copyright (C) 2014, 2016  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 <stdlib.h>

#include <stddef.h>

#include <stdio.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <time.h>

#include <errno.h>

#include <fcntl.h>

#ifdef WIN32

#include <windows.h>

#include <io.h>

#else

#include <dirent.h>

#endif

#include <glib.h>

#include <glib/gstdio.h>

#include "config.h"

#include "plover.h"

#include "uri-handler.h"

#ifndef FALSE

#define FALSE	0

#endif

#ifndef TRUE

#define TRUE	(!FALSE)

#endif

#define MAX_OLD_LOGFILES	4	/* (5 including the current) */

#ifdef WIN32

struct find_suffixed_data {

    HANDLE handle;

    WIN32_FIND_DATA wfd;

    int base_len;

    char *suffix;

};

static int find_suffixed_first(const char *path,struct find_suffixed_data *data)

{

    const char *t1,*t2;

    gchar *s;

    s=g_strconcat(path,"-*",NULL);

    data->handle=FindFirstFile(s,&data->wfd);

    g_free(s);

    if (data->handle==INVALID_HANDLE_VALUE)

	return FALSE;

    t1=strrchr(path,'/');

    t2=strrchr(t1?t1:path,'\\');

    if (t2)

	data->base_len=strlen(t2+1);

    else if (t1)

	data->base_len=strlen(t1+1);

    else

	data->base_len=strlen(path);

    data->suffix=strdup(data->wfd.cFileName+data->base_len);

    return TRUE;

}

static int find_suffixed_next(struct find_suffixed_data *data)

{

    if (!FindNextFile(data->handle,&data->wfd))

	return FALSE;

    free(data->suffix);

    data->suffix=strdup(data->wfd.cFileName+data->base_len);

    return TRUE;

}

static void find_suffixed_close(struct find_suffixed_data *data)

{

    free(data->suffix);

    FindClose(data->handle);

}

#else	/* WIN32 */

struct find_suffixed_data {

    DIR *dir;

    struct dirent *entry;

    char *base;

    int base_len;

    char *suffix;

};

static int find_suffixed_next(struct find_suffixed_data *data)

{

    struct dirent *entry_result;

    while (!readdir_r(data->dir,data->entry,&entry_result) && entry_result)

    {

	if (strncmp(data->entry->d_name,data->base,data->base_len) ||

	  data->entry->d_name[data->base_len]!='-')

	    continue;

	free(data->suffix);

	data->suffix=strdup(data->entry->d_name+data->base_len);

	return TRUE;

    }

    return FALSE;

}

/*

 * From http://womble.decadent.org.uk/readdir_r-advisory.html

 *

 * Calculate the required buffer size (in bytes) for directory

 * entries read from the given directory handle. Return -1 if this

 * this cannot be done.

 *

 * This code does not trust values of NAME_MAX that are less than

 * 255, since some systems (including at least HP-UX) incorrectly

 * define it to be a smaller value.

 *

 * If you use autoconf, include fpathconf and dirfd in your

 * AC_CHECK_FUNCS list. Otherwise use some other method to detect

 * and use them where available.

 */

static size_t dirent_buf_size(DIR * dirp)

{

    long name_max;

    size_t name_end;

#if defined(HAVE_FPATHCONF) && defined(HAVE_DIRFD) && defined(_PC_NAME_MAX)

    name_max=fpathconf(dirfd(dirp),_PC_NAME_MAX);

    if (name_max==-1)

#if defined(NAME_MAX)

	name_max=(NAME_MAX>255)?NAME_MAX:255;

#else

	return (size_t)-1;

#endif	/* NAME_MAX */

#else

#if defined(NAME_MAX)

    name_max=(NAME_MAX>255)?NAME_MAX:255;

#else

#error "buffer size for readdir_r cannot be determined"

#endif	/* NAME_MAX */

#endif	/* HAVE_FPATHCONF && HAVE_DIRFD && _PC_NAME_MAX */

    name_end=(size_t)offsetof(struct dirent,d_name)+name_max+1;

    return (name_end>sizeof(struct dirent)?name_end:sizeof(struct dirent));

}

static int find_suffixed_first(const char *path,struct find_suffixed_data *data)

{

    int len;

    char *s,*base;

    base=strrchr(path,'/');

    if (base)

    {

	if (base==path)

	    data->dir=opendir("/");

	else

	{

	    s=strndup(path,base-path);

	    data->dir=opendir(s);

	    free(s);

	}

	data->base=strdup(base+1);

    }

    else

    {

	data->dir=opendir(".");

	data->base=strdup(path);

    }

    if (!data->dir)

    {

	free(data->base);

	return FALSE;

    }

    data->base_len=strlen(data->base);

    len=dirent_buf_size(data->dir);

    if (len<0)

    {

	closedir(data->dir);

	return FALSE;

    }

    data->entry=malloc(len);

    if (!data->entry)

    {

	closedir(data->dir);

	return FALSE;

    }

    data->suffix=NULL;

    if (find_suffixed_next(data))

	return TRUE;

    free(data->entry);

    closedir(data->dir);

    return FALSE;

}

static void find_suffixed_close(struct find_suffixed_data *data)

{

    free(data->base);

    free(data->suffix);

    free(data->entry);

    closedir(data->dir);

}

#endif	/* WIN32 */

static int prune_old_logfiles(const char *path)

{

    int i,n_suffixes;

    gchar *s;

    char *suffix,*suffixes[MAX_OLD_LOGFILES];

    struct find_suffixed_data fsd;

    if (find_suffixed_first(path,&fsd))

    {

	n_suffixes=0;

	do

	{

	    suffix=strdup(fsd.suffix);

	    if (n_suffixes<MAX_OLD_LOGFILES)

		suffixes[n_suffixes++]=suffix;

	    else

	    {

		for(i=0;i<MAX_OLD_LOGFILES;i++)

		    if (strcmp(suffix,suffixes[i])>0)

		    {

			s=suffixes[i];

			suffixes[i]=suffix;

			suffix=s;

		    }

		s=g_strconcat(path,suffix,NULL);

		(void)remove(s);

		g_free(s);

		free(suffix);

	    }

	} while(find_suffixed_next(&fsd));

	find_suffixed_close(&fsd);

	for(i=0;i<n_suffixes;i++)

	    free(suffixes[i]);

    }

    return 0;

}

static int rotate_logfile(const char *path,struct tm *modified)

{

    gboolean okay_to_replace;

    gchar *s;

    char serial;

    char suffix[11];			/* -yyyymmdd or -yyyymmdds */

    sprintf(suffix,"-%04d%02d%02d",modified->tm_year+1900,modified->tm_mon+1,

      modified->tm_mday);

    s=g_strconcat(path,suffix,NULL);

    if (g_file_test(s,G_FILE_TEST_EXISTS) || g_rename(path,s))

    {

	suffix[10]='\0';

	for(serial='a';serial<='z';serial++)

	{

	    free(s);

	    suffix[9]=serial;

	    s=g_strconcat(path,suffix,NULL);

	    if (serial=='z')

		okay_to_replace=TRUE;

	    else

		okay_to_replace=!g_file_test(s,G_FILE_TEST_EXISTS);

	    if (okay_to_replace && !g_rename(path,s))

		break;

	    else if (serial=='z')

	    {

		fprintf(stderr,"%s%s: Failed to rotate logfile\n",path,suffix);

		free(s);

		return -1;

	    }

	}

    }

    g_free(s);

    return prune_old_logfiles(path);

}

int plover_log_open(const char *path)

{

    int retval;

    char *root;

    gchar *filename,*uri;

    struct stat sb;

    time_t t;

    struct tm today,modified;

    struct razor_atomic *atomic;

    GFile *base_file,*file;

    FILE *fp;

    plover__uri_handler_init();

    root=getenv("RAZOR_ROOT");

    if (root)

    {

	base_file=g_file_new_for_uri(root);

	if (g_path_is_absolute(path))

	    path=g_path_skip_root(path);

	file=g_file_resolve_relative_path(base_file,path);

	g_object_unref(base_file);

	filename=g_file_get_path(file);

	if (!filename)

	{

	    fprintf(stderr,"%s: Can't get local path\n",g_file_get_uri(file));

	    g_object_unref(file);

	    return -1;

	}

	g_object_unref(file);

    }

    else

	filename=g_strdup(path);

    uri=razor_path_to_uri(filename);

    atomic=razor_atomic_open("Open log");

    razor_atomic_make_dirs(atomic,"",uri);

    retval=razor_atomic_commit(atomic);

    if (retval)

	fprintf(stderr,"Can't open log: %s\n",

	  razor_atomic_get_error_msg(atomic));

    razor_atomic_destroy(atomic);

    g_free(uri);

    if (retval)

    {

	g_free(filename);

	return retval;

    }

    if (stat(filename,&sb)<0)

    {

	if (errno!=ENOENT)

	{

	    perror("Can't open log");

	    g_free(filename);

	    return -1;

	}

    }

    else if (!S_ISREG(sb.st_mode))

    {

	fprintf(stderr,"Can't open log: %s: Not a regular file\n",filename);

	g_free(filename);

	return -1;

    }

    else

    {

	time(&t);

#if HAVE_LOCALTIME_R

	localtime_r(&t,&today);

	localtime_r(&sb.st_mtime,&modified);

#else

	today=*localtime(&t);

	modified=*localtime(&sb.st_mtime);

#endif

	if (modified.tm_yday!=today.tm_yday || modified.tm_year!=today.tm_year)

	    rotate_logfile(filename,&modified);

    }

    fp=fopen(filename,"a");

    if (!fp)

    {

	fprintf(stderr,"Can't open log: ");

	perror(filename);

	g_free(filename);

	return -1;

    }

    g_free(filename);

#ifdef WIN32

    /*

     * The situation under MS-Windows is a little complicated. If standard

     * output and standard error are valid then the normal code will work.

     * This applies in console applications and even in GUI applications

     * if standard output and standard error are redirected by the parent

     * process (eg., by cmd.exe). However GUI applications started in

     * typical fashion will have invalid standard output and standard error.

     * See http://support.microsoft.com/kb/105305 for some more detail.

     * NB: This solution assumes that fd 1 and 2 are either used for

     * standard output/error or are unused.

     */

    fclose(stdout);

    fclose(stderr);

#else

    fflush(stdout);

    fflush(stderr);

#endif

    if (dup2(fileno(fp),1)<0 || dup2(fileno(fp),2)<0)

    {

	perror("Failed to redirect standard error/output");

	fclose(fp);

	return -1;

    }

    fclose(fp);

#ifdef WIN32

    *stdout=*fdopen(1,"a");

    setvbuf(stdout,NULL,_IONBF,0);

    *stderr=*fdopen(2,"a");

    setvbuf(stderr,NULL,_IONBF,0);

    SetStdHandle(STD_OUTPUT_HANDLE,(HANDLE)_get_osfhandle(1));

    SetStdHandle(STD_ERROR_HANDLE,(HANDLE)_get_osfhandle(2));

#endif

    time(&t);

    printf("Run started on %s",ctime(&t));

    fflush(stdout);

    return 0;

}