/*
 *  R.app : a Cocoa front end to: "R A Computer Language for Statistical Data Analysis"
 *  
 *  R.app Copyright notes:
 *                     Copyright (C) 2005  The R Foundation
 *                     written by Stefano M. Iacus and Simon Urbanek
 *
 *                  
 *  R Copyright notes:
 *                     Copyright (C) 1995-1996   Robert Gentleman and Ross Ihaka
 *                     Copyright (C) 1998-2001   The R Development Core Team
 *                     Copyright (C) 2002-2005   The R Foundation
 *
 *  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.
 *
 *  A copy of the GNU General Public License is available via WWW at
 *  http://www.gnu.org/copyleft/gpl.html.  You can also obtain it by
 *  writing to the Free Software Foundation, Inc., 59 Temple Place,
 *  Suite 330, Boston, MA  02111-1307  USA.
 *
 *  Created by Simon Urbanek on Tue Jul 13 2004.
 *
 */

/* #include "privateR.h" */
#include <R.h>
#include <Rdefines.h>
#include <Rinternals.h>
#include <Rversion.h>

#include <sys/select.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/time.h>

#include <R_ext/Boolean.h>
#include <R_ext/Rdynload.h>
#include <R_ext/Parse.h>
#include <R_ext/eventloop.h>

#import "REngine.h"

/* any subsequent calls of ProcessEvents within the following time slice are ignored (in ms) */
#define MIN_DELAY_BETWEEN_EVENTS_MS   150

/* localization - we don't want to include GUI specific includes, so we define it manually */
#ifdef NLS
#undef NLS
#endif
#ifdef NLSC
#undef NLSC
#endif
#define NLS(S) NSLocalizedString(S,@"")
#define NLSC(S,C) NSLocalizedString(S,C)

#ifndef SLog
#if defined DEBUG_RGUI && defined PLAIN_STDERR
#define SLog(X,...) NSLog(X, ## __VA_ARGS__)
#else
#define SLog(X,...)
#endif
#endif

/* for compatibility with R registration - unused here */
#define checkArity(X,Y)

/* we have no access to config.h, so for the moment, let's disable i18n on C level - our files aren't even precessed by R anyway. */
#ifdef _
#undef _
#endif
#define _(A) (A)

int insideR = 0;

/* from Defn.h */
extern Rboolean R_Interactive;   /* TRUE during interactive use*/

extern FILE*    R_Consolefile;   /* Console output file */
extern FILE*    R_Outputfile;   /* Output file */

/* from src/unix/devUI.h */

extern void (*ptr_R_Suicide)(char *);
extern void (*ptr_R_ShowMessage)();
extern int  (*ptr_R_ReadConsole)(char *, unsigned char *, int, int);
extern void (*ptr_R_WriteConsole)(char *, int);
extern void (*ptr_R_ResetConsole)();
extern void (*ptr_do_flushconsole)();
extern void (*ptr_R_ClearerrConsole)();
extern void (*ptr_R_Busy)(int);
/* extern void (*ptr_R_CleanUp)(SA_TYPE, int, int); */
//extern int  (*ptr_R_ShowFiles)(int, char **, char **, char *, Rboolean, char *);
//extern int  (*ptr_R_EditFiles)(int, char **, char **, char *);
extern int  (*ptr_R_ChooseFile)(int, char *, int);
extern void (*ptr_R_loadhistory)(SEXP, SEXP, SEXP, SEXP);
extern void (*ptr_R_savehistory)(SEXP, SEXP, SEXP, SEXP);

//extern void (*ptr_R_StartCocoaRL)();

void Re_WritePrompt(char *prompt)
{
	NSString *s = [[NSString alloc] initWithUTF8String: prompt];
	insideR--;
    [[REngine mainHandler] handleWritePrompt:s];
	[s release];
	insideR++;
}

static long lastProcessEvents=0;

void Re_ProcessEvents(void){
	struct timeval rv;
	if (!gettimeofday(&rv,0)) {
		long curTime = (rv.tv_usec/1000)+(rv.tv_sec&0x1fffff)*1000;
		if (curTime - lastProcessEvents < MIN_DELAY_BETWEEN_EVENTS_MS) return;
	}
#ifdef USE_POOLS
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
#endif
	if ([[REngine mainEngine] allowEvents]) // if events are masked, we won't call the handler. we may re-think what we do about the timer, though ...
		[[REngine mainHandler] handleProcessEvents];
	if (!gettimeofday(&rv,0)) // use the exit time for the measurement of next events - handleProcessEvents may take long
		lastProcessEvents = (rv.tv_usec/1000)+(rv.tv_sec&0x1fffff)*1000;
#ifdef USE_POOLS
	[pool release];
#endif
}

static char *readconsBuffer=0;
static char *readconsPos=0;

int Re_ReadConsole(char *prompt, unsigned char *buf, int len, int addtohistory)
{
	insideR--;
	Re_WritePrompt(prompt);

	if (!readconsBuffer) {
	    char *newc = [[REngine mainHandler] handleReadConsole: addtohistory];
	    if (!newc) {
			insideR++;
			return 0;
		}
		readconsPos=readconsBuffer=newc;
	}
		
	if (readconsBuffer) {
		int skipPC=0;
		char *c = readconsPos;
		while (*c && *c!='\n' && *c!='\r') c++;
		if (*c=='\r') { /* convert PC and Mac endings to unix */
			*c='\n';
			if (c[1]=='\n') skipPC=1;
		}
        if (*c) c++; /* if not at the end, point past the content to use */
        if (c-readconsPos>=len) c=readconsPos+(len-1);
        memcpy(buf, readconsPos, c-readconsPos);
		buf[c-readconsPos]=0;
        if (skipPC) c++;
		if (*c)
			readconsPos=c;
		else
			readconsPos=readconsBuffer=0;
		[[REngine mainHandler] handleProcessingInput: (char*) buf];
insideR=YES;
		return 1;
	}

    return 0;
}

void Re_RBusy(int which)
{
	insideR--;
    [[REngine mainHandler] handleBusy: (which==0)?NO:YES];
	insideR++;
}


void Re_WriteConsoleEx(char *buf, int len, int otype)
{
	NSString *s = nil;
	if (buf[len]) { /* well, this is an ultima ratio, we are assuming null-terminated string, but one never knows ... */
		char *c = (char*) malloc(len+1);
		memcpy(c, buf, len);
		c[len]=0;
		s = [[NSString alloc] initWithUTF8String:c];
		free(c);
	} else s = [[NSString alloc] initWithUTF8String:buf];
    if (!s) {
		SLog(@"Rcallbacks:Re_WriteConsole: suspicious string of length %d doesn't parse as UTF8. Will use raw cString.", len);
		s = [[NSString alloc] initWithCString:buf length:len];
		SLog(@"Rcallbacks:Re_WriteConsole: string parsed as \"%@\"", s);
	}
    if (s) {
		[[REngine mainHandler] handleWriteConsole: s withType: otype];
		[s release];
	}
}

void Re_WriteConsole(char *buf, int len)
{
    Re_WriteConsoleEx(buf, len, 0);
}

/* Indicate that input is coming from the console */
void Re_ResetConsole()
{
}

/* Stdio support to ensure the console file buffer is flushed */
void Re_FlushConsole()
{
	insideR--;
	[[REngine mainHandler] handleFlushConsole];	
	insideR++;
}

/* Reset stdin if the user types EOF on the console. */
void Re_ClearerrConsole()
{
}

int Re_ChooseFile(int new, char *buf, int len)
{
	int r;
	insideR--;
	r=[[REngine mainHandler] handleChooseFile: buf len:len isNew:new];
	insideR++;
	return r;
}

void Re_ShowMessage(char *buf)
{
	insideR--;
	[[REngine mainHandler] handleShowMessage: buf];
	insideR++;
}

int  Re_Edit(char *file){
	int r;
	insideR--;
	r=[[REngine mainHandler] handleEdit: file];
	insideR++;
	return r;
}

int  Re_EditFiles(int nfile, char **file, char **wtitle, char *pager){
	int r;
	insideR--;
	r = [[REngine mainHandler] handleEditFiles: nfile withNames: file titles: wtitle pager: pager];
	insideR++;
	return r;
}

int Re_ShowFiles(int nfile, char **file, char **headers, char *wtitle, Rboolean del, char *pager)
{
	int r;
	insideR--;
	r = [[REngine mainHandler] handleShowFiles: nfile withNames: file headers: headers windowTitle: wtitle pager: pager andDelete: del];
	insideR++;
	return r;
}

//==================================================== the following callbacks are Cocoa-specific callbacks (see CocoaHandler)

int Re_system(char *cmd) {
	int r;
	insideR--;
	if ([REngine cocoaHandler])
		r = [[REngine cocoaHandler] handleSystemCommand: cmd];
	else { // fallback in case there's no handler
		   // reset signal handlers
		signal(SIGINT, SIG_DFL);
		signal(SIGTERM, SIG_DFL);
		signal(SIGQUIT, SIG_DFL);
		signal(SIGALRM, SIG_DFL);
		signal(SIGCHLD, SIG_DFL);
		r = system(cmd);
	}
	insideR++;
	return r;
}

int  Re_CustomPrint(char *type, SEXP obj)
{
	insideR--;
	if ([REngine cocoaHandler]) {
		RSEXP *par = [[RSEXP alloc] initWithSEXP: obj];
		int res = [[REngine cocoaHandler] handleCustomPrint: type withObject: par];
		[par release];
		insideR++;
		return res;
	}
	insideR++;
	return -1;
}

SEXP Re_packagemanger(SEXP call, SEXP op, SEXP args, SEXP env)
{
	SEXP pkgname, pkgstatus, pkgdesc, pkgurl;
	char *vm;
	SEXP ans; 
	int i, len;
	
	char **sName, **sDesc, **sURL;
	BOOL *bStat;
	
	checkArity(op, args);

	if (![REngine cocoaHandler]) return R_NilValue;
	
	vm = vmaxget();
	pkgstatus = CAR(args); args = CDR(args);
	pkgname = CAR(args); args = CDR(args);
	pkgdesc = CAR(args); args = CDR(args);
	pkgurl = CAR(args); args = CDR(args);
  
	if(!isString(pkgname) || !isLogical(pkgstatus) || !isString(pkgdesc) || !isString(pkgurl))
		errorcall(call, "invalid arguments");
   
	len = LENGTH(pkgname);
	if (len!=LENGTH(pkgstatus) || len!=LENGTH(pkgdesc) || len!=LENGTH(pkgurl))
		errorcall(call, "invalid arguments (length mismatch)");

	if (len==0) {
		insideR--;
		[[REngine cocoaHandler] handlePackages: 0 withNames: 0 descriptions: 0 URLs: 0 status: 0];
		insideR++;
		vmaxset(vm);
		return pkgstatus;
	}

	sName = (char**) malloc(sizeof(char*)*len);
	sDesc = (char**) malloc(sizeof(char*)*len);
	sURL  = (char**) malloc(sizeof(char*)*len);
	bStat = (BOOL*) malloc(sizeof(BOOL)*len);

	i = 0; // we don't copy since the Obj-C side is responsible for making copies if necessary
	while (i<len) {
		sName[i] = (char*)CHAR(STRING_ELT(pkgname, i));
		sDesc[i] = (char*)CHAR(STRING_ELT(pkgdesc, i));
		sURL [i] = (char*)CHAR(STRING_ELT(pkgurl, i));
		bStat[i] = (BOOL)LOGICAL(pkgstatus)[i];
		i++;
	}
	insideR--;
	[[REngine cocoaHandler] handlePackages: len withNames: sName descriptions: sDesc URLs: sURL status: bStat];
	insideR++;
	free(sName); free(sDesc); free(sURL);
	
	PROTECT(ans = NEW_LOGICAL(len));
	for(i=0;i<len;i++)
		LOGICAL(ans)[i] = bStat[i];
	UNPROTECT(1);
	free(bStat);
	
	vmaxset(vm);
  	return ans;
}

SEXP Re_datamanger(SEXP call, SEXP op, SEXP args, SEXP env)
{
  SEXP  dsets, dpkg, ddesc, durl, ans;
  char *vm;
  int i, len;
  
  char **sName, **sDesc, **sURL, **sPkg;
  BOOL *res;

  checkArity(op, args);

  vm = vmaxget();
  dsets = CAR(args); args = CDR(args);
  dpkg = CAR(args); args = CDR(args);
  ddesc = CAR(args); args = CDR(args);
  durl = CAR(args);
  
  if (!isString(dsets) || !isString(dpkg) || !isString(ddesc)  || !isString(durl) )
	errorcall(call, "invalid arguments");

  len = LENGTH(dsets);
  if (LENGTH(dpkg)!=len || LENGTH(ddesc)!=len || LENGTH(durl)!=len)
	  errorcall(call, "invalid arguments (length mismatch)");
	  
  if (len==0) {
	  insideR--;
	  [[REngine cocoaHandler] handleDatasets: 0 withNames: 0 descriptions: 0 packages: 0 URLs: 0];
	  insideR++;
	  vmaxset(vm);
	  return R_NilValue;
  }

  sName = (char**) malloc(sizeof(char*)*len);
  sDesc = (char**) malloc(sizeof(char*)*len);
  sURL  = (char**) malloc(sizeof(char*)*len);
  sPkg  = (char**) malloc(sizeof(char*)*len);
  
  i = 0; // we don't copy since the Obj-C side is responsible for making copies if necessary
  while (i<len) {
	  sName[i] = (char*)CHAR(STRING_ELT(dsets, i));
	  sDesc[i] = (char*)CHAR(STRING_ELT(ddesc, i));
	  sURL [i] = (char*)CHAR(STRING_ELT(durl, i));
	  sPkg [i] = (char*)CHAR(STRING_ELT(dpkg, i));
	  i++;
  }

  insideR--;
  res = [[REngine cocoaHandler] handleDatasets: len withNames: sName descriptions: sDesc packages: sPkg URLs: sURL];
  insideR++;
  
  free(sName); free(sDesc); free(sPkg); free(sURL);
  
  if (res) {
	  PROTECT(ans=allocVector(LGLSXP, len));
	  i=0;
	  while (i<len) {
		  LOGICAL(ans)[i]=res[i];
		  i++;
	  }
	  UNPROTECT(1);
  } else {
	  // this should be the default:	  ans=R_NilValue;
	  // but until the R code is fixed to accept this, we have to fake a result
	  ans=allocVector(LGLSXP, 0);
  }
  
  vmaxset(vm);
  
  return ans;
}

SEXP Re_browsepkgs(SEXP call, SEXP op, SEXP args, SEXP env)
{
  char *vm;
  int i, len;
  SEXP rpkgs, rvers, ivers, wwwhere, install_dflt;

  char **sName, **sIVer, **sRVer;
  BOOL *bStat;

  checkArity(op, args);

  vm = vmaxget();
  rpkgs = CAR(args); args = CDR(args);
  rvers = CAR(args); args = CDR(args);
  ivers = CAR(args); args = CDR(args);
  wwwhere = CAR(args); args=CDR(args);
  install_dflt = CAR(args); 
  
  if(!isString(rpkgs) || !isString(rvers) || !isString(ivers) || !isString(wwwhere) || !isLogical(install_dflt))
	  errorcall(call, "invalid arguments");

  len = LENGTH(rpkgs);
  if (LENGTH(rvers)!=len || LENGTH(ivers)!=len || LENGTH(wwwhere)<1 || LENGTH(install_dflt)!=len)
	  errorcall(call, "invalid arguments (length mismatch)");
	  
  if (len==0) {
	  insideR--;
	  [[REngine cocoaHandler] handleInstalledPackages: 0 withNames: 0 installedVersions: 0 repositoryVersions: 0 update: 0 label: 0];
	  insideR++;
	  vmaxset(vm);
	  return R_NilValue;
  }
  
  sName = (char**) malloc(sizeof(char*)*len);
  sIVer = (char**) malloc(sizeof(char*)*len);
  sRVer = (char**) malloc(sizeof(char*)*len);
  bStat = (BOOL*) malloc(sizeof(BOOL)*len);
  
  i = 0; // we don't copy since the Obj-C side is responsible for making copies if necessary
  while (i<len) {
	  sName[i] = (char*)CHAR(STRING_ELT(rpkgs, i));
	  sIVer[i] = (char*)CHAR(STRING_ELT(ivers, i));
	  sRVer[i] = (char*)CHAR(STRING_ELT(rvers, i));
	  bStat[i] = (BOOL)LOGICAL(install_dflt)[i];
	  i++;
  }
  
  insideR--;
  [[REngine cocoaHandler] handleInstalledPackages: len withNames: sName installedVersions: sIVer repositoryVersions: sRVer update: bStat label:(char*)CHAR(STRING_ELT(wwwhere,0))];
  insideR++;
  free(sName); free(sIVer); free(sRVer); free(bStat);
    
  vmaxset(vm);
  return allocVector(LGLSXP, 0);
}

SEXP Re_do_hsbrowser(SEXP call, SEXP op, SEXP args, SEXP env)
{
	char *vm;
	SEXP ans; 
	int i, len;
	SEXP h_topic, h_pkg, h_desc, h_wtitle, h_url;
	char **sTopic, **sDesc, **sPkg, **sURL;
	
	checkArity(op, args);
	
	vm = vmaxget();
	h_topic = CAR(args); args = CDR(args);
	h_pkg = CAR(args); args = CDR(args);
	h_desc = CAR(args); args = CDR(args);
	h_wtitle = CAR(args); args = CDR(args);
	h_url = CAR(args); 
	
	if(!isString(h_topic) | !isString(h_pkg) | !isString(h_desc) )
		errorcall(call, "invalid arguments");
	
	len = LENGTH(h_topic);
	if (LENGTH(h_pkg)!=len || LENGTH(h_desc)!=len || LENGTH(h_wtitle)<1 || LENGTH(h_url)!=len)
		errorcall(call, "invalid arguments (length mismatch)");
	
	if (len==0) {
		insideR--;
		[[REngine cocoaHandler] handleHelpSearch: 0 withTopics: 0 packages: 0 descriptions: 0 urls: 0 title: 0];
		insideR++;
		vmaxset(vm);
		return R_NilValue;
	}
	
	sTopic = (char**) malloc(sizeof(char*)*len);
	sDesc = (char**) malloc(sizeof(char*)*len);
	sPkg = (char**) malloc(sizeof(char*)*len);
	sURL = (char**) malloc(sizeof(char*)*len);
	
	i = 0; // we don't copy since the Obj-C side is responsible for making copies if necessary
	while (i<len) {
		sTopic[i] = (char*)CHAR(STRING_ELT(h_topic, i));
		sDesc[i]  = (char*)CHAR(STRING_ELT(h_desc, i));
		sPkg[i]   = (char*)CHAR(STRING_ELT(h_pkg, i));
		sURL[i]   = (char*)CHAR(STRING_ELT(h_url, i));
		i++;
	}
	
	insideR--;
	[[REngine cocoaHandler] handleHelpSearch: len withTopics: sTopic packages: sPkg descriptions: sDesc urls: sURL title:(char*)CHAR(STRING_ELT(h_wtitle,0))];
	insideR++;
	free(sTopic); free(sDesc); free(sPkg); free(sURL);
	
	PROTECT(ans = NEW_LOGICAL(len));
	for(i=0;i<len;i++)
		LOGICAL(ans)[i] = 0;
	
	vmaxset(vm);  
	UNPROTECT(1);
	
	return ans;
}

SEXP Re_do_selectlist(SEXP call, SEXP op, SEXP args, SEXP rho)
{
    SEXP list, preselect, ans = R_NilValue;
    char **clist;
    int i, j = -1, n,  multiple, nsel = 0;
	Rboolean haveTitle;
	BOOL *itemStatus = 0;
	int selectListDone = 0;
	
    checkArity(op, args);
    list = CAR(args);
    if(!isString(list)) error(_("invalid 'list' argument"));
    preselect = CADR(args);
    if(!isNull(preselect) && !isString(preselect))
		error(_("invalid 'preselect' argument"));
    multiple = asLogical(CADDR(args));
    if(multiple == NA_LOGICAL) multiple = 0;
    haveTitle = isString(CADDDR(args));
    if(!multiple && isString(preselect) && LENGTH(preselect) != 1)
		error(_("invalid 'preselect' argument"));
	
    n = LENGTH(list);
    clist = (char **) R_alloc(n + 1, sizeof(char *));
    itemStatus = (BOOL *) R_alloc(n + 1, sizeof(BOOL));
    for(i = 0; i < n; i++) {
		clist[i] = (char*)CHAR(STRING_ELT(list, i));
		itemStatus[i] = NO;
    }
    clist[n] = NULL;
	
    if(!isNull(preselect) && LENGTH(preselect)) {
		for(i = 0; i < n; i++)
			for(j = 0; j < LENGTH(preselect); j++)
				if(strcmp(clist[i], CHAR(STRING_ELT(preselect, j))) == 0) {
					itemStatus[i] = YES;
					break;
				};
    }
	
	insideR--;
	if (n==0)
		selectListDone = [[REngine cocoaHandler] handleListItems: 0 withNames: 0 status: 0 multiple: 0 title: @""];
	else
		selectListDone = [[REngine cocoaHandler] handleListItems: n withNames: clist status: itemStatus multiple: multiple
														   title: haveTitle
			?[NSString stringWithUTF8String: CHAR(STRING_ELT(CADDDR(args), 0))]
			:(multiple ? NLS(@"Select one or more") : NLS(@"Select one")) ];
	insideR++;
	
	if (selectListDone == 1) { /* Finish */
		for(i = 0; i < n; i++)  if(itemStatus[i]) nsel++;
		PROTECT(ans = allocVector(STRSXP, nsel));
		for(i = 0, j = 0; i < n; i++)
			if(itemStatus[i])
				SET_STRING_ELT(ans, j++, mkChar(clist[i]));
	} else { /* cancel */
		PROTECT(ans = allocVector(STRSXP, 0));
	}

    UNPROTECT(1);
    return ans;
}