/* Author:   Clare Quarman, cquarman@pp.rhul.ac.uk
 * Date:     Thurs 13 Nov 2003
 * Purpose:  C++ wrapper for QCDNUM1612
 *           All the functions defined here are designed to act 
 *           just like their QCDNUM counterparts do.
 *           Refer to QCDNUM writeup and manual for further details.
 * Modified: 08/09/05  implemented qfromiq & evplus
 */


#include "QCDnum.h"
#include <fstream>
#include <iostream>

using std::string;
using std::ifstream;
using std::cerr;
using std::cout;
using std::endl;
using std::remove;

/* prototype */
extern "C" {
  void  openhelper_(int&, char*, long int);
  void  closehelper_(int&);
  void  writefile_(int&, char*, long int);
  void  qnvershelper_(bool&, int&, int&);
  void  f_init(); // for fortran I/O initialisation. Called in qninit
  void  f_exit(); // opposite of f_init

  // QCDNUM functions & subroutines:
  void   qninit_();
  void   qnvers_(char*, bool&, int&, int&, long int);
  void   qntime_(char*, long int);
  void   qnlset_(char*, bool&, long int);
  void   qniset_(char*, int&, long int);
  void   qnrset_(char*, double&, long int);
  void   qnlget_(char*, bool&, long int);
  void   qniget_(char*, int&, long int);
  void   qnrget_(char*, double&, long int);
  void   grxdef_(int&, double&);
  void   grqdef_(int&, double&, double&);
  void   grxinp_(double[], int&);
  void   grqinp_(double[], int&);
  void   grxnul_();                 //wrapper to write
  void   grqnul_();                 //wrapper to write
  void   grmxmq_(int&, int&);       //wrapper to write
  void   grgive_(int&, double&, double&, int&, double&, double&);
  void   grxout_(double[]);         //wrapper to write
  void   grqout_(double[]);         //wrapper to write
  double xfromix_(int&);
  double qfromiq_(int&);            //wrapper to write
  int    ixfromx_(double&);         //wrapper to write
  int    iqfromq_(double&);
  int    ixnearx_(double&);         //wrapper to write
  int    iqnearq_(double&);         //wrapper to write
  void   grcuts_(double&, double&, double&, double&);//wrapper to write
  int    ifailij_(int&, int&);      //wrapper to write
  int    ifailxq_(double&, double&);//wrapper to write
  void   qnfilw_(int&, int&);
  void   qndump_(int&);
  void   qnread_(int&, int&, int&);
  void   qnbook_(int&, char*, long int);
  void   qnlinc_(int&, char*, int&, double[], long int);
  int    ipdfid_(char*, long int);  //wrapper to write
  void   qthres_(double&, double&);
  int    nflget_(int&);             //wrapper to write
  double qalfas_(double&, double&, int&, int&); //wrapper to write
  void   qnpset_(char*, int&, int&, double&, long int);
  void   qaddsi_(char*, int&, double&, long int);//wrapper to write
  void   qnpnul_(char*, long int);  //wrapper to write
  void   evolsg_(int&, int&, int&);
  void   evolnp_(char*, int&, int&, int&, long int);
  void   evolnm_(char*, int&, int&, int&, long int);
  void   evplus_(char*, int&, int&, int&, long int); //wrapper to write  
  double qpdfij_(char*, int&, int&, int&, long int); //wrapper to write
  double qpdfxq_(char*, double&, double&, int&, long int);
  double qstfij_(char*, char*, int&, int&, int&, long int, long int); //wrapper to write
  double qstfxq_(char*, char*, double&, double&, int&, long int, long int);
  void   qfmark_(double&, double&); //wrapper to write
  void   qfmnul_();                 //wrapper to write
  void   stfast_(char*, char*, long int, long int); //wrapper to write
  void   stfclr_();                 //wrapper to write
  void   qprint_(int&, char*, long int);
}


void FortranIO::openFileWithLun(int lun, string filename){
  long int namelen = filename.length();
  const char * bob = filename.c_str();
  char* c=new char[namelen+1];
  strcpy(c,bob);
  
  openhelper_(lun, c, namelen);
  
  delete[] c;
  return;
}

void FortranIO::closeFileWithLun(int lun){
  closehelper_(lun);
  return;
} 

void FortranIO::writeToFileWithLun(int lun, string output){
  long int outputlen = output.length();
  const char * bob = output.c_str();
  char* c=new char[outputlen+1];
  strcpy(c,bob);
  
  writefile_(lun, c, outputlen);
  
  delete[] c;
  return;
}



// sucessfully tested? yes
void QCDnum::qninit(){
  f_init(); // possibly needed for mixing C and Fortran I/O but seems not.
  qninit_();
  return;
}

  /*
  // sucessfully tested? nope!
  void QCDnum::qnvers0(string* s, bool& l, int& i, int& j){
    string t = "error";
    s=&t;
    l=false;
    i=0;
    j=0;
    const long int slen = 8;
    char c[slen+1];
    qnvers_(c, l, i, j, slen);
    c[slen]='\0';
    *s=c;
    return;
  }
  */

// sucessfully tested? I think so
void QCDnum::qnvers1(string& s, bool& l, int& i, int& j){
  const long int slen = 8;
  char c[slen+1];
  qnvers_(c, l, i, j, slen);
  c[slen]='\0';
  s=c;
  return;
}

// sucessfully tested? I think so
void QCDnum::qnvers2(char* c, bool& l, int& i, int& j){
  const long int slen = 8;
  qnvers_(c, l, i, j, slen);
  c[slen]='\0';
  return;
}

// sucessfully tested? I think so
void QCDnum::qnvers3(string& s, bool& l, int& i, int& j){
  qnvershelper_(l,i,j);
  ifstream infile("qcdnumWrapperHelper.temp");
  if (! infile){
    cerr << "error: unable to open qcdnumWrapperHelper.temp" << endl;
  }
  infile >> s;
  if (remove("qcdnumWrapperHelper.temp")==-1){
    cerr << "error: unable to remove qcdnumWrapperHelper.temp" << endl;
  }
  return;
}

// identical to qnvers3
// sucessfully tested? I think so
void QCDnum::qnvers4(string& s, bool& l, int& i, int& j){
  qnvershelper_(l,i,j);
  ifstream infile("qcdnumWrapperHelper.temp");
  if (! infile){
    cerr << "error: unable to open qcdnumWrapperHelper.temp" << endl;
  }
  infile >> s;
  if (remove("qcdnumWrapperHelper.temp")==-1){
    cerr << "error: unable to remove qcdnumWrapperHelper.temp" << endl;
  }
  return;
}


// sucessfully tested? yes
void QCDnum::qntime(string s){
  long int slen = s.length();
  const char * bob = s.c_str();
  
  char* c = new char[slen+1]; //+1 to include the end character
  strcpy(c,bob);
  
  qntime_(c, slen);           //doesn't hurt here if c in fact longer than slen
  
  delete[] c;
  return;
}

// not tested yet
void QCDnum::qnlset(string s, bool l){
  long int slen = s.length();
  const char * bob = s.c_str();
  char* c=new char[slen+1];
  strcpy(c,bob);
  qnlset_(c, l, slen);
  delete[] c;
  return;
}

// not tested yet
void QCDnum::qniset(string s, int i){
  long int slen = s.length();
  const char * bob = s.c_str();
  char* c=new char[slen+1];
  strcpy(c,bob);
  qniset_(c, i, slen);
  delete[] c;
  return;
}

// sucessfully tested
void QCDnum::qnrset(string s, double x){
  long int slen = s.length();
  const char * bob = s.c_str();
  char* c=new char[slen+1];
  strcpy(c,bob);
  qnrset_(c, x, slen);
  delete[] c;
  return;
}

// not tested yet
void QCDnum::qnlget(string s, bool& l){
  long int slen = s.length();
  const char * bob = s.c_str();
  char* c=new char[slen+1];
  strcpy(c,bob);
  qnlget_(c, l, slen);
  delete[] c;
  return;
}

// not tested yet
void QCDnum::qniget(string s, int& i){
  long int slen = s.length();
  const char * bob = s.c_str();
  char* c=new char[slen+1];
  strcpy(c,bob);
  qniget_(c, i, slen);
  delete[] c;
  return;
}

// sucessfully test
void QCDnum::qnrget(string s, double& x){
  long int slen = s.length();
  const char * bob = s.c_str();
  char* c=new char[slen+1];
  strcpy(c,bob);
  qnrget_(c, x, slen);
  delete[] c;    
  return;
}

// sucessfully tested
void QCDnum::grxdef(int i, double x){
  grxdef_(i, x);
  return;
}

// sucessfully tested
void QCDnum::grqdef(int i, double x, double y){
  grqdef_(i, x, y);
  return;
}

// sucessfully tested - horray! 8/12/04
void QCDnum::grxinp(double x[], int i){
  grxinp_(x, i);
  return;
}

// sucessfully tested - horray! 8/12/04
void QCDnum::grqinp(double x[], int i){
  grqinp_(x, i);
  return;
}

/*  TO DO:
    void   QCDnum::grxnul_();                 //wrapper to write
    void   QCDnum::grqnul_();                 //wrapper to write
    void   QCDnum::grmxmq_(int&, int&);       //wrapper to write
*/

// sucessfully tested? yes
void QCDnum::grgive(int& i, double& x, double& y , int& j, double& z, double& w){
  grgive_(i, x, y, j, z, w);
  return;
}

/////////////////////////////////////HERE////////////////////////////////////

/*
  void   QCDnum::grxout_(double[]);         //wrapper to write
  void   QCDnum::grqout_(double[]);         //wrapper to write
*/

// sucessfully tested? yes
double QCDnum::xfromix(int i){
  double x = xfromix_(i);
  return x;
}

//sucessfully tested
double QCDnum::qfromiq(int i){
  double q = qfromiq_(i);
  return q;
}


/*
  int    QCDnum::ixfromx_(double&);         //wrapper to write
*/

// sucessfully tested? yes
int QCDnum::iqfromq(double x){
  int i = iqfromq_(x);
  return i;
}

/*
  int    QCDnum::ixnearx_(double&);         //wrapper to write
  int    QCDnum::iqnearq_(double&);         //wrapper to write
  void   QCDnum::grcuts_(double&, double&, double&, double&);//wrapper to write
  int    QCDnum::ifailij_(int&, int&);      //wrapper to write
  int    QCDnum::ifailxq_(double&, double&);//wrapper to write
*/

// sucessfully tested? yes
void QCDnum::qnfilw(int i, int j){
  qnfilw_(i, j);
  return;
}

// sucessfully tested - horray! 8/1/04
void QCDnum::qndump(int lun){
  qndump_(lun);
  return;
}

// sucessfully tested - horray! 8/1/04
void QCDnum::qnread(int lun, int i , int& j){
  qnread_(lun, i, j);
  return;
}


// sucessfully tested? yes
void QCDnum::qnbook(int i, string s){
  long int slen = s.length();
  const char * bob = s.c_str();
  char* c=new char[slen+1];
  strcpy(c,bob);
  qnbook_(i, c, slen);
  delete[] c;
  return;
}

void QCDnum::qnlinc(int i, string s, int j, double x[]){
  long int slen = s.length();
  const char * bob = s.c_str();
  char* c=new char[slen+1];
  strcpy(c,bob);
  qnlinc_(i, c, j, x, slen);
  delete[] c;
  return;
}

/*
  int    QCDnum::ipdfid_(char*, long int);  //wrapper to write
*/

// sucessfully tested? yes
void QCDnum::qthres(double x, double y){
  qthres_(x, y);
  return;
}

/*
  int    QCDnum::nflget_(int&);             //wrapper to write
  double QCDnum::qalfas_(double&, double&, int&, int&); //wrapper to write
*/

// sucessfully tested
void QCDnum::qnpset(string s, int i, int j, double x){
  long int slen = s.length();
  const char * bob = s.c_str();
  
  char* c = new char[slen+1];
  strcpy(c,bob);
  
  qnpset_(c, i, j, x, slen);
  
  delete[] c;
  return;
}

/*
  void   QCDnum::qaddsi_(char*, int&, double&, long int);//wrapper to write
  void   QCDnum::qnpnul_(char*, ling int);  //wrapper to write
*/

// sucessfully tested
void QCDnum::evolsg(int i, int j, int k){
  evolsg_(i, j, k);
  return;
}


void QCDnum::evolnp(string s, int i, int j, int k){
  long int slen = s.length();
  const char * bob = s.c_str();
  
  char* c = new char[slen+1];
  strcpy(c,bob);
  
  evolnp_(c, i, j, k, slen);
  
  delete[] c;
  return;
}

void QCDnum::evolnm(string s, int i, int j, int k){
  long int slen = s.length();
  const char * bob = s.c_str();
  
  char* c = new char[slen+1];
  strcpy(c,bob);
  
  evolnm_(c, i, j, k, slen);
  
  delete[] c;
  return;
}

//successfully tested
void QCDnum::evplus(string s, int i, int j, int k){
  long int slen = s.length();
  const char * bob = s.c_str();
  
  char* c = new char[slen+1];
  strcpy(c,bob);  

  evplus_(c, i, j, k, slen);

  delete[] c;
  return;
}

/*
  double QCDnum::qpdfij_(char*, int&, int&, int&, long int); //wrapper to write
*/

// sucessfully tested
double QCDnum::qpdfxq(string s, double x, double y, int & i){
  long int slen = s.length();
  const char * bob = s.c_str();
  char* c=new char[slen+1];
  strcpy(c,bob);
  double result = qpdfxq_(c, x, y, i, slen);
  delete[] c;
  return result;
}

/*
  double QCDnum::qstfij_(char*, char*, int&, int&, int&, long int, long int); //wrapper to write
*/

// sucessfully tested
double QCDnum::qstfxq(string s, string t, double x, double y, int& i){
  long int slen = s.length();
  long int tlen = t.length();
  const char * bob = s.c_str();
  const char * bub = t.c_str();
  char* c = new char[slen+1]; 
  char* d = new char[tlen+1];
  strcpy(c,bob);
  strcpy(d,bub);
  double result = qstfxq_(c, d, x, y, i, slen, tlen);
  delete[] c;
  delete[] d;
  cout << result << endl;
  return result;
}

/*
  void   QCDnum::qfmark_(double&, double&); //wrapper to write
  void   QCDnum::qfmnul_();                 //wrapper to write
  void   QCDnum::stfast_(char*, char*, long int, long int); //wrapper to write
  void   QCDnum::stfclr_();                 //wrapper to write
*/

// sucessfully tested
void QCDnum::qprint(int i, string s){
  long int slen = s.length();
  const char * bob = s.c_str();
  char* c=new char[slen+1];
  strcpy(c,bob);
  qprint_(i, c, slen);
  delete[] c;
  return;
}

void QCDnum::endQCDnum(){
  f_exit();
  return;
}