/*

 * Copyright (C) 2009, 2011, 2014, 2015  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 <stdarg.h>

#include <string.h>

#include <limits.h>

#ifdef WIN32

#include <windows.h>

#include <shlobj.h>

#endif

#include <glib.h>

#include <glib/gstdio.h>

#include "config.h"

#include "plover.h"

gchar *plover_default_prefix_for_vendor(const char *vendor)

{

#ifdef WIN32

    /*

     * We want to sidestep any redirecting that MS-Windows may

     * introduce since this will be based on the architecture

     * of the installer whereas the architecture that actually

     * matters is of the packages (checked elsewhere).

     */

    BOOL is_wow64=FALSE;

    typedef BOOL (WINAPI *is_wow64_process_t)(HANDLE,PBOOL);

    is_wow64_process_t is_wow64_process;

    char *program_files=NULL;

    char buf[PATH_MAX];

    is_wow64_process=(is_wow64_process_t)

      GetProcAddress(GetModuleHandleA("kernel32"),"IsWow64Process");

    if (is_wow64_process)

	is_wow64_process(GetCurrentProcess(),&is_wow64);

    if (is_wow64)

	program_files=getenv("ProgramW6432");

    if (!program_files)

    {

	SHGetFolderPath(NULL,CSIDL_PROGRAM_FILES|CSIDL_FLAG_DONT_VERIFY,NULL,0,

	  buf);

	program_files=buf;

    }

    return g_strconcat(program_files,"\\",vendor?vendor:"Plover",NULL);

#else

    const char *vendor_prefix;

    vendor_prefix=g_getenv("PLOVER_VENDOR_PREFIX");

    if (!vendor_prefix)

	return NULL;

    else

	return g_build_filename(vendor_prefix,vendor?vendor:"Plover",NULL);

#endif

}

gchar *plover_pre_install_prefix(void)

{

#ifdef WIN32

    {

	HRESULT result;

	HKEY key;

	DWORD type,nb;

	int len;

	gunichar2 *str2;

	gchar *root=NULL;

	result=RegOpenKeyW(HKEY_LOCAL_MACHINE,L"Software\\Plover",&key);

	if (result==ERROR_SUCCESS)

	{

	    result=RegQueryValueExW(key,L"Root",0,&type,0,&nb);

	    if (result==ERROR_SUCCESS && type==REG_SZ)

	    {

		str2=malloc(nb);

		result=RegQueryValueExW(key,L"Root",0,NULL,(void *)str2,&nb);

		len=nb/2;

		if (!str2[len-1])       /* Cope with unterminated strings */

		    len--;

		root=g_utf16_to_utf8(str2,len,NULL,NULL,NULL);

		free(str2);

	    }

	    RegCloseKey(key);

	}

	if (!root)

	{

	    root=plover_default_prefix_for_vendor("Plover Root");

	    result=RegCreateKeyExW(HKEY_LOCAL_MACHINE,L"Software\\Plover",0,

	      NULL,REG_OPTION_NON_VOLATILE,KEY_READ|KEY_WRITE,NULL,&key,NULL);

	    if (result==ERROR_SUCCESS)

	    {

		str2=g_utf8_to_utf16(root,-1,NULL,NULL,NULL);

		RegSetValueExW(key,L"Root",0,REG_SZ,(void *)str2,

		  (strlen(root)+1)*sizeof(gunichar2));

		g_free(str2);

		RegCloseKey(key);

	    }

	}

	return root;

    }

#else

    return g_strdup("/var/lib/plover/root");

#endif

}

#define MAX_REPORTS     12

struct plover_util_file {

    gchar *name;

    time_t mtime;

};

static int plover_util_compare_files(gconstpointer a,gconstpointer b)

{

    struct plover_util_file *fa=(struct plover_util_file *)a;

    struct plover_util_file *fb=(struct plover_util_file *)b;

    return fa->mtime-fb->mtime;

}

/*

 * Limit the number of reports to MAX_REPORTS

 */

void plover_purge_reports(const char *path)

{

    const char *name;

    GStatBuf sbuf;

    int count=0;

    GDir *d;

    GError *err=NULL;

    GList *files=NULL;

    struct plover_util_file *file;

    d=g_dir_open(path,0,&err);

    if (!d)

    {

	if (g_error_matches(err,G_FILE_ERROR,G_FILE_ERROR_NOENT))

	    g_mkdir_with_parents(path,0777);

	return;

    }

    while(count<=MAX_REPORTS && g_dir_read_name(d))

	count++;

    if (count>MAX_REPORTS)

    {

	g_dir_rewind(d);

	while((name=g_dir_read_name(d)))

	{

	    file=g_new(struct plover_util_file,1);

	    file->name=g_build_filename(path,name,NULL);

	    if (!g_stat(file->name,&sbuf))

		file->mtime=sbuf.st_mtime;

	    else

		file->mtime=0;

	    files=g_list_prepend(files,file);

	}

	files=g_list_sort(files,plover_util_compare_files);

	while(files)

	{

	    file=(struct plover_util_file *)files->data;

	    if (count>MAX_REPORTS)

	    {

		count--;

		g_remove(file->name);

	    }

	    g_free(file->name);

	    g_free(file);

	    files=g_list_delete_link(files,files);

	}

    }

    g_dir_close(d);

}

gchar *plover_get_reports_directory(void)

{

    gchar *path=NULL;

#ifdef WIN32

    HKEY key;

    DWORD rtype,nb;

    int len;

    long retval;

    gunichar2 *str2;

    char *dir;

    retval=RegOpenKeyW(HKEY_LOCAL_MACHINE,L"Software\\Plover",&key);

    if (SUCCEEDED(retval))

    {

	nb=200;

	str2=malloc(nb);

	retval=RegQueryValueExW(key,L"Reports",0,&rtype,(void *)str2,&nb);

	if (retval==ERROR_MORE_DATA)

	{

	    g_free(str2);

	    str2=malloc(nb);

	    retval=RegQueryValueExW(key,L"Reports",0,NULL,(void *)str2,&nb);

	}

	if (SUCCEEDED(retval) && rtype==REG_SZ)

	{

	    len=nb/2;

	    if (!str2[len-1])       /* Cope with unterminated strings */

		len--;

	    path=g_utf16_to_utf8(str2,len,NULL,NULL,NULL);

	}

	RegCloseKey(key);

	g_free(str2);

    }

    if (!path)

    {

	WCHAR wpath[MAX_PATH];

	retval=SHGetFolderPathW(NULL,CSIDL_COMMON_APPDATA,NULL,

	SHGFP_TYPE_CURRENT,wpath);

	if (SUCCEEDED(retval))

	    dir=g_utf16_to_utf8((const gunichar2 *)wpath,-1,NULL,NULL,NULL);

	else

	    dir=g_strdup(

	      "C:\\Documents and Settings\\All Users\\Application Data");

	path=g_build_filename(dir,"plover","reports",NULL);

	g_free(dir);

    }

#else

    path=g_strdup("/var/lib/plover/reports");

#endif

    plover_purge_reports(path);

    return path;

}

char *plover_get_program(const char *argv0)

{

#ifdef WIN32

    char path[PATH_MAX];

    GetModuleFileName(NULL,path,sizeof(path));

    return strdup(path);

#else

    return strdup(argv0);

#endif

}

/*

 * Get the directory containing the program executable.

 */

char *plover_get_program_directory(const char *argv0)

{

    char *s;

#ifdef WIN32

    char path[PATH_MAX],*t;

    GetModuleFileName(NULL,path,sizeof(path));

    s=strrchr(path,'/');

    if (s)

    {

	t=strrchr(s,'\\');

	if (t)

	    s=t;

    }

    else

	s=strrchr(path,'\\');

    if (s)

	*s='\0';

    return strdup(path);

#else

    s=argv0?strrchr(argv0,'/'):NULL;

    if (s)

	return strndup(argv0,s-argv0);

    else

	return strdup(".");

#endif

}

G_DEFINE_QUARK(plover-razor-error-quark,plover_razor_error)

G_DEFINE_QUARK(plover-mswin-error-quark,plover_mswin_error)

G_DEFINE_QUARK(plover-posix-error-quark,plover_posix_error)

G_DEFINE_QUARK(plover-zlib-error-quark,plover_zlib_error)

void plover_propagate_razor_error_dup(GError **dest,struct razor_error *src)

{

    GQuark domain;

    int code;

    if (dest)

    {

	code=razor_error_get_code(src);

	switch(razor_error_get_domain(src))

	{

	    case RAZOR_GENERAL_ERROR:

		domain=PLOVER_RAZOR_ERROR;

		break;

	    case RAZOR_POSIX_ERROR:

		domain=PLOVER_POSIX_ERROR;

		break;

	    case RAZOR_MSWIN_ERROR:

		domain=PLOVER_MSWIN_ERROR;

		break;

	    case RAZOR_ZLIB_ERROR:

		domain=PLOVER_ZLIB_ERROR;

		break;

	    case PLOVER_GENERAL_ERROR:

		if (code==PLOVER_GENERAL_ERROR_CANCELLED)

		{

		    domain=G_IO_ERROR;

		    code=G_IO_ERROR_CANCELLED;

		    break;

		}

		/* else fall though */

	    default:

		domain=PLOVER_RAZOR_ERROR;

		code=RAZOR_GENERAL_ERROR_FAILED;

	}

	*dest=g_error_new_literal(domain,code,razor_error_get_msg(src));

    }

}

void plover_propagate_razor_error(GError **dest,struct razor_error *src)

{

    plover_propagate_razor_error_dup(dest,src);

    razor_error_free(src);

}

void plover_propagate_g_error(struct razor_error **dest,GError *src)

{

    int domain,code;

    if (dest)

    {

	code=src->code;

	if (src->domain==PLOVER_RAZOR_ERROR)

	    domain=RAZOR_GENERAL_ERROR;

	else if (src->domain==PLOVER_POSIX_ERROR)

	    domain=RAZOR_POSIX_ERROR;

	else if (src->domain==PLOVER_MSWIN_ERROR)

	    domain=RAZOR_MSWIN_ERROR;

	else if (src->domain==PLOVER_ZLIB_ERROR)

	    domain=RAZOR_ZLIB_ERROR;

	else if (src->domain==G_IO_ERROR && code==G_IO_ERROR_CANCELLED)

	{

	    domain=PLOVER_GENERAL_ERROR;

	    code=PLOVER_GENERAL_ERROR_CANCELLED;

	}

	else

	{

	    domain=RAZOR_GENERAL_ERROR;

	    code=RAZOR_GENERAL_ERROR_FAILED;

	}

	*dest=razor_error_new_str(domain,code,NULL,src->message);

    }

    g_error_free(src);

}