/*

                                                         ##
                                                         ##
                         #########                       ##
          ##########    ##########    ###        ###     ##
          ##########    ##            ####      ####     ##      ##########
          ##            ##            ##  ##  ##  ##     ##      ##########
          ##            ########      ##  ##  ##  ##     ##      ##
          ######         ########     ##    ##    ##     ##      ##
          ######               ###    ##    ##    ##     ##############
          ##     ###     ##    ##########         ##     ##############
          ##     ###    #################        ########        ##
          ###########   #########     ##         #########       ##
          ###########    ##    ##     ##         ###    ##       ##########
                 ##  ##  ##    ######            ##     ##       ##########
                 ##  ##  ##    ######            ########
                 ##    # ##    ##                #########
                 ##    # ##    ##                ##      ##
                 ##     ###    ##########        ##      ##
                 ##     ###    ##########        ##########
                                                 #########
                                                                                   */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
**                                                                                 **
**                                                                                 **
**                                 E N S E M B L E                                 **
**                                                                                 **
**                                   Version 2.1                                   **
**                                                                                 **
**                                                                                 **
**                   Principal Investigator: Julie D. Forman-Kay                   **
**                                                                                 **
**                           Author:  Mickaël Krzeminski                           **
**                                                                                 **
**                               Date: November 2012                               **
**                                                                                 **
**                                                                                 **
*************************************************************************************
**                                                                                 **
**                                                                                 **
**   Copyright (C) The Hospital for Sick Children, 2001                            **
**                                                                                 **
**   Distribution of substantively modified versions of this module is prohibited  **
**  without the explicit permission of the copyright holder.                       **
**                                                                                 **
**   Any use of this work or derivative works in whole or in part for any          **
**  commercial purpose or for monetary gain is prohibited.                         **
**                                                                                 **
**                                                                                 **
**                                   NO WARRANTY                                   **
**   This software package is provided 'as is' without warranty of any kind,       **
**  expressed or implied.                                                          **
**                                                                                 **
**                                                                                 **
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*
   COMPILATION
                gcc -O3 -o surface surface.c
*/

#include "Include/ens.h"

enum toolsPrograms TP = __SURFACE__;

int main (int argc, char *argv[])
{
	/***********************************************************\
	|*                                                         *|
	|*                                                         *|
	|*                  Variables declaration                  *|
	|*                                                         *|
	|*                                                         *|
	\***********************************************************/
	counter count;

	char mode = 'A';		// a => access, c => contact
	char radius = 'S';		// s => sigma,  v => vdw

	char *PDBFileName = NULL, *outFileName = NULL, *FFName = NULL;
	char resn[4] = {'\0'}, resi[5] = {'\0'}, name[5] = {'\0'};

	PDBListData ENSData = {0, 0, NULL, NULL};

	double probe = 1.6;
	double accuracy = 0.05;

	accessSurf as;

	FILE *outFile;

	/***********************************************************\
	|*                                                         *|
	|*                                                         *|
	|*             Arguments  reading and checking             *|
	|*                                                         *|
	|*                                                         *|
	\***********************************************************/
	for (count=1; count<argc; count++)
	{
		if (!strcmp(argv[count], "-f"))
		{
			++count;
			if (argc>count)
			{
				if (argv[count][0] == '-') fatal_error("INVALID_ARGUMENT", argv[count]);
				if ((PDBFileName = malloc((strlen(argv[count]) + 1) * CHAR_SIZE)) == NULL)
				{
					fatal_error("MEMORY", "create PDBFileName variable");
				}
				strcpy(PDBFileName, argv[count]);
			}
			else
			{
				fatal_error("NO_ARGUMENT_FLAG", "-f");
			}
		}
		else if (!strcmp(argv[count], "-o"))
		{
			++count;
			if (argc>count)
			{
				if (argv[count][0] == '-') fatal_error("INVALID_ARGUMENT", argv[count]);
				if ((outFileName = malloc(strlen(argv[count]) * CHAR_SIZE + 1)) == NULL)
				{
					fatal_error("MEMORY", "create outFileName variable");
				}
				strcpy(outFileName, argv[count]);
			}
			else
			{
				fatal_error("NO_ARGUMENT_FLAG", "-o");
			}
		}
		else if (!strcmp(argv[count], "-rh2o") )
		{
			++count;
			if (argc>count)
			{
				if ((argv[count][0] == '-') || (probe = atof(argv[count])) < 1E-8) fatal_error("INVALID_ARGUMENT", argv[count]);
			}
			else
			{
				fatal_error("NO_ARGUMENT_FLAG", "-rh2o");
			}
		}
		else if (!strcmp(argv[count], "-accuracy") )
		{
			++count;
			if (argc>count)
			{
				if ((argv[count][0] == '-') || (accuracy = atof(argv[count])) < 1E-8) fatal_error("INVALID_ARGUMENT", argv[count]);
			}
			else
			{
				fatal_error("NO_ARGUMENT_FLAG", "-accuracy");
			}
		}
		else if (!strcmp(argv[count], "-mode") )
		{
			++count;
			if (argc>count)
			{
				mode = toupper(argv[count][0]);
				if (mode != 'A' && mode != 'C') fatal_error("INVALID_ARGUMENT", argv[count]);
			}
			else
			{
				fatal_error("NO_ARGUMENT_FLAG", "-mode");
			}
		}
		else if (!strcmp(argv[count], "-radius") )
		{
			++count;
			if (argc>count)
			{
				mode = toupper(argv[count][0]);
				if (mode != 'S' && mode != 'V') fatal_error("INVALID_ARGUMENT", argv[count]);
			}
			else
			{
				fatal_error("NO_ARGUMENT_FLAG", "-radius");
			}
		}
		else if (!strcmp(argv[count], "-ff"))
		{
			++count;
			if (argc>count)
			{
				if (argv[count][0] == '-') fatal_error("INVALID_ARGUMENT", argv[count]);
				if ((FFName = malloc((strlen(argv[count]) + 1) * CHAR_SIZE)) == NULL)
				{
					fatal_error("MEMORY", "create FFName variable");
				}
				strcpy(FFName, argv[count]);
			}
			else
			{
				fatal_error("NO_ARGUMENT_FLAG", "-ff");
			}
		}
		else if (!strcmp(argv[count], "-h"))
		{
			__USAGE__
		}
		else
		{
			warning("ARGUMENT", argv[count]);
		}
	}


	// Checking whether a list file has been provided
	if (PDBFileName == NULL)
	{
		__USAGE__
	}

	// Checking the selected Force Field
	if (FFName == NULL)
	{
		FFName = calloc(6, CHAR_SIZE);
		strcpy(FFName, "OPLSX");
	}

	/***********************************************************\
	|*                                                         *|
	|*                                                         *|
	|*          Calculation of the accessible surface          *|
	|*                                                         *|
	|*                                                         *|
	\***********************************************************/

	// Checking whether the file exists
	if (PDBFileName[strlen(PDBFileName)-1] == '\n') PDBFileName[strlen(PDBFileName)-1] = '\0';

	if (getCoords(&ENSData, PDBFileName, NULL)) fatal_error("A problem occured while recording coordinates from the %s file.", PDBFileName);
	
	as = getAccSurf(&ENSData, FFName, probe, mode, radius, accuracy);
	if (as.FAILED)
	{
		error("A problem was encountered in the accessible area calculation from file %s.\nThe program will be aborting.\n\n", PDBFileName);
		_cleanm(&ENSData, PDBFileName, outFileName, FFName, as);
		return 1;
	}

	// Displaying the results in an elegant way
	
	if (outFileName == NULL)
	{
		outFile = stdout;
	}
	else
	{
		if ((outFile = fopen(outFileName, "w")) == NULL)
		{
			error("Impossible to open the %s file.\nThe results will be displayed on screen.\n\n", outFileName);
			outFile = stdout;
		}
	}


	if (mode == 'A')
	{
		fprintf(outFile, "! Surface: Accessible surface area\n");
	}
	else
	{
		fprintf(outFile, "! Surface: Contact area\n");
	}
	
	fprintf(outFile, "!\tAccuracy:\t%f\n", accuracy);
	fprintf(outFile, "!\tH2O radius:\t%f\n", probe);
	fprintf(outFile, "!\tZ-grid:\t%f\n", as.zres);
	fprintf(outFile, "!\tNumber of z sections:\t%d\n", as.zsecnb);
	fprintf(outFile, "!\tMeasure of arc:\t%d and %d\n", as.icnt1, as.icnt2);


	for (count=0; count<ENSData.nbAtoms; count++)
	{
		strncpy(resn, &ENSData.atomHeaders[count][17], 3);	// Residue name
		strncpy(resi, &ENSData.atomHeaders[count][22], 4);	// Residue number
		strncpy(name, &ENSData.atomHeaders[count][12], 4);	// Atom name

		fprintf(outFile, "%3s %4s %4s %10.4f\n", resn, resi, name, as.as[count]);
	}

	fclose(outFile);
	_cleanm(&ENSData, PDBFileName, outFileName, FFName, as);

	return 0;
}