/******************************************************************************/
/*                                                                            */
/* Author: Kareem Carr                                                        */
/*                                                                            */
/* Purpose: To compute feature vectors of a protein                           */
/*                                                                            */
/* Usage: The directory in which the executable is stored is assumed to con-  */
/*        tain protein sequences stored in text files.  The program computes  */
/*        feature vectors for these protein sequences and stores them in a    */
/*        csv file with the name of the text file adjacent to the 60 numbers  */
/*        which comprise the feature vector.                                  */
/*                                                                            */
/* Input: The program uses text files (*.txt) containing the fasta sequence.  */
/*                                                                            */
/* Output: A list of feature vectors stored in the file 'parameteroutput.csv' */
/*                                                                            */
/******************************************************************************/

#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include <cmath>
#include <stdio.h>

using namespace std;

/* Function: gettextfiles (string directory, vector<string> &filelist) 

   Collects the names of all files with a *.txt extension.  */
   
void gettextfiles (string directory, vector<string> &filelist)
{
    DIR *directorypointer;
    struct dirent *information;
    
    directorypointer = opendir(directory.c_str());
    
    if(directorypointer == NULL)
    {
        std::cout << "There was a failure to open directory:" << directory<<"."<<std::endl;
    }
    
    string filename;
    
    /* If ".txt" is changed then the program can be adapted to a different file extension
       from the default *.txt extension */
    
    information = readdir(directorypointer);
    if(filename.find(".txt",0)!=string::npos) filelist.push_back(string(information->d_name));        
    
    while (information != NULL)
    {
	   filename = string(information->d_name);
	   if(filename.find(".txt",0)!=string::npos)
	   {
		 filelist.push_back(filename);
	   }   
       information = readdir(directorypointer);             
    }
    closedir(directorypointer);
}

/* Function: getdata(string filename, string &data) 

   Returns a string containing the contents of a specified 
   file.  It assumes the file is shorter than 20,000 cha-
   racters.  For longer files, increase the number.  */
   
void getdata(string filename, string &data)
{
  data.clear();
  char buffer[20000];
  
  std::ifstream infile (filename.c_str());    

  if (infile.bad())
  {
	  std::cout<<"Unable to open file:"<<filename<<std::endl;
	  exit(0);
  }   	


  infile.getline(buffer,20000);
  
  data = string(buffer);
  
  infile.close();  	
}

/* Function: int index(char c)

   This function maps either the upper or lower case letter
   designation of an amino acid to an index between 1
   and 20. */
   
int index(char c)
{
   if (c == 'A') return( 0); //Ala 4
   if (c == 'R') return( 1); //Arg 6
   if (c == 'N') return( 2); //Asn 2
   if (c == 'D') return( 3); //Asp 2
   if (c == 'C') return( 4); //Cys 2
   
   if (c == 'E') return( 5); //Glu 2
   if (c == 'Q') return( 6); //Gln 2
   if (c == 'G') return( 7); //Gly 4
   if (c == 'H') return( 8); //His 2
   if (c == 'I') return( 9); //Ile 3
   
   if (c == 'L') return(10); //Leu 6
   if (c == 'K') return(11); //Lys 2
   if (c == 'M') return(12); //Met 1
   if (c == 'F') return(13); //Phe 2
   if (c == 'P') return(14); //Pro 4
   
   if (c == 'S') return(15); //Ser 6
   if (c == 'T') return(16); //Thr 4
   if (c == 'W') return(17); //Trp 1
   if (c == 'Y') return(18); //Tyr 2
   if (c == 'V') return(19); //Val 4

   if (c == 'a') return( 0); //Ala 4
   if (c == 'r') return( 1); //Arg 6
   if (c == 'n') return( 2); //Asn 2
   if (c == 'd') return( 3); //Asp 2
   if (c == 'c') return( 4); //Cys 2
   
   if (c == 'e') return( 5); //Glu 2
   if (c == 'q') return( 6); //Gln 2
   if (c == 'g') return( 7); //Gly 4
   if (c == 'h') return( 8); //His 2
   if (c == 'i') return( 9); //Ile 3
   
   if (c == 'l') return(10); //Leu 6
   if (c == 'k') return(11); //Lys 2
   if (c == 'm') return(12); //Met 1
   if (c == 'f') return(13); //Phe 2
   if (c == 'p') return(14); //Pro 4
   
   if (c == 's') return(15); //Ser 6
   if (c == 't') return(16); //Thr 4
   if (c == 'w') return(17); //Trp 1
   if (c == 'y') return(18); //Tyr 2
   if (c == 'v') return(19); //Val 4

   std::cout<<"failed to index character ("<<c<<")"<<std::endl;
   return(-1);
}


int main(int argc, char *argv[])
{
   string outfilename;

    /* processing of commandline parameters */
    if(argc == 1)
    {
	   outfilename.assign("parameteroutput.csv");
	}
	else if (argc == 2)
	{
       outfilename.assign(argv[1]);
	}
	else
	{
		std::cout<<"This program takes one parameter: the name of the output file."<<std::endl;
		std::cout<<"Use no parameters in order to get the default output file.    "<<std::endl;
	}

	std::ofstream outfile (outfilename.c_str());   
	  
    if (outfile.bad())
    {
	  std::cout<<"Unable to open file:"<<outfilename<<std::endl;
	  exit(0);
    } 

	string directory = string(".");
    vector<string> filelist = vector<string>();

    gettextfiles(directory,filelist);
    
    long double n[20];
    long double T[20];
    long double D[20];
    
	/* This is a basic a priori assumption about the expected frequency of amino acid.
	   It is possible to compute the probabilities for the sample and use that instead.*/

    long double pr[20] = {4,6,2,2,2,
                           2,2,4,2,3,
                           6,2,1,2,4,
                           6,4,1,2,4};

    for(long int i=0;i<20;i++) pr[i] = pr[i]/61;

    long double nm,nv,Tm,Tv,Dm,Dv;        
    
    int p;
    
    string data;
    
    for (int i = 0;i < filelist.size();i++)
    {
      for (p = 0;p < 20;p++)
      {
	    n[p] = 0;
	    T[p] = 0;
	    D[p] = 0;
      } 	         

            
      getdata(filelist[i],data); 
      std::cout<<filelist[i]<<"("<<data.size()<<")"<<std::endl;     
	  
	  long double delta;
	  
	  long double N;
	  N = 0;
	  

	  
	  /* number, mean and variance */ 
	  for(int j = 0;j < data.size(); j++)
	  {
	    N = N + 1;
		   
		  p = index(data[j]);	    	  
	    
	    if ((p == -1)&&isalpha(data[j]))
	    { 
		    std::cout<<"An unexpected alphanumeric character was found:"<<filelist[i]<<std::endl;  
		    continue;
      }

      if ((p == -1)&&isdigit(data[j]))
	    { 
		    std::cout<<"An unexpected numeric character was found:"<<filelist[i]<<std::endl;
		    exit(0);
      }
        
        
      if(!(isalpha(data[j])))
		  {
        std::cout<<"An unexpected and invalid character was found in file:"<<filelist[i]<<std::endl;
        exit(0);
		  }		
		
	    n[p]  = n[p] + 1;
	    delta = j+1 - T[p];
	    T[p]  = T[p] + delta/n[p];
	    D[p]  = D[p] + delta*(j+1-T[p]);	    	    
	  } 
	  
	  outfile<<filelist[i]<<",";
	  
 	  for(p = 0;p < 20; p++)
	  {     		 		   		  
	      /* bias correction */
	      if (n[p] > 1)
	      {		  
	        D[p] = D[p]/(n[p]-1);  	      
	        D[p] = (D[p] * (N-1) )/N;
        }        
        
        /* normalization of the parameters for the theoretical population.  Most of the formulas are introductory
           statistics.*/
        nm = pr[p];
        nv = (pr[p]*(1-pr[p]))/N;
        
        Tm = (N+1)/2;
        Tv = ((N+1)*(N-n[p]))/(12*n[p]);
        
        Dm = ((N*N)-1)/12; 
        
        /* based on the "The variance of the variance of samples from a finite population." Cho, Cho and Eltinge */       
        Dv = ((N-n[p])*(N-1)*(N-1)*(N+1)*( (2*n[p]*N) + (3*N) + (3*n[p]) + 3))/(360*n[p]*(n[p]-1)*N);
        
        
        nv = sqrt(nv);
        Tv = sqrt(Tv);
        Dv = sqrt(Dv);
                               
        T[p] = (T[p] - Tm)/Tv;
        D[p] = (D[p] - Dm)/Dv;


        /* The edge cases for small numbers of amino acids when some of the defined values
		   fail to exist and when the whole string corresponding to a particular type of 
		   amino acid is a single amino acid. */

        if (n[p] <= 1)
        {
	      D[p] = 0;
        }		   

        if (n[p] == 0) T[p] = 0;
        if (n[p] == N) D[p] = 0;
        if (n[p] == N) T[p] = 0;
        
        /* n[p] is needed above in its unchanged form so converting it to a probability is
           done here */
		           
        n[p] = n[p]/N;                                
        n[p] =  (n[p] - nm)/nv;        

        /* Output feature vectors information to a file */
        outfile<<","<<n[p]<<","<<T[p]<<","<<D[p];              
        
        if (p == 19)
        {
	      outfile<<std::endl;    
        }                 
	  }
    }

    outfile.close();
    return (0);
}

/* Note: This program can easily be adapted to compute parameters for nucleic acid sequences. */