/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
**                                                                                 **
**                                                                                 **
**                                                       **                        **
**                                                       **                        **
**                       *********                       **                        **
**        **********    **********    ***        ***     **                        **
**        **********    **            ****      ****     **      **********        **
**        **            **            **  **  **  **     **      **********        **
**        **            ********      **  **  **  **     **      **                **
**        ******         ********     **    **    **     **      **                **
**        ******               ***    **    **    **     **************            **
**        **     ***     **    **********         **     **************            **
**        **     ***    *****************        ********        **                **
**        ***********   *********     **         *********       **                **
**        ***********    **    **     **         ***    **       **********        **
**               **  **  **    ******            **     **       **********        **
**               **  **  **    ******            ********                          **
**               **    * **    **                *********                         **
**               **    * **    **                **      **                        **
**               **     ***    **********        **      **                        **
**               **     ***    **********        **********                        **
**                                               *********                         **
**                                                                                 **
**                                                                                 **
**                          E N S E M B L E     T O O L S                          **
**                                                                                 **
**                                   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.                                                          **
**                                                                                 **
**                                                                                 **
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#ifndef __SS_HEADER__
#define __SS_HEADER__


/***********************************************************\
|*                                                         *|
|*                                                         *|
|*                    STRIDE executable                    *|
|*                                                         *|
|*                                                         *|
\***********************************************************/

void _clean_ss_distr(PDBListData *ENSData, secondaryStructure *statSecStr, residueList *residueNbs, char *PDBListFileName, char *outFileName)
{
    _cleanPDB(ENSData);

    if (statSecStr != NULL)
    {
        free((*statSecStr).Helix);    (*statSecStr).Helix     = NULL;
        free((*statSecStr).Pihelix);  (*statSecStr).Pihelix   = NULL;
        free((*statSecStr).Helix310); (*statSecStr).Helix310  = NULL;
        free((*statSecStr).Strand);   (*statSecStr).Strand    = NULL;
        free((*statSecStr).Coil);     (*statSecStr).Coil      = NULL;
        free((*statSecStr).Turn);     (*statSecStr).Turn      = NULL;
        free((*statSecStr).Bridge);   (*statSecStr).Bridge    = NULL;
    }

    if (residueNbs != NULL)
    {
        free((*residueNbs).nbs);
        (*residueNbs).nbs = NULL;
    }

    free(PDBListFileName); PDBListFileName = NULL;
    free(outFileName); outFileName = NULL;
}


secondaryStructure runStride (char *strideProg, char *PDBFileName)
{
    /*
       Returns the secondary structure of each
       residue of PDBFileName
    */

    secondaryStructure pdbSS = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0};
    char strideOutLine[STRIDE_LINE_LEN];
    char strideType[4] = {'\0'};
    char *strideExecute ;
    char ERROR[6];

    unsigned int maxNbResidues = 0;

    FILE *strideOut;            // STRIDE output

    if ((strideExecute = malloc((strlen(strideProg) + strlen(PDBFileName) + 2) * CHAR_SIZE)) == NULL) fatal_error("MEMORY", "instance strideExecute variable");
    strcpy(strideExecute, strideProg);
    strideExecute = strcat(strcat(strideExecute, " "), PDBFileName);

    strideOut = popen(strideExecute, "r");
    fgets(strideOutLine, STRIDE_LINE_LEN, strideOut);
    strncpy(ERROR, strideOutLine, 5);
    if (strcmp(ERROR, "Error"))
    {
        while (fgets(strideOutLine, STRIDE_LINE_LEN, strideOut) != NULL)
        {
            strncpy(strideType, strideOutLine, 3);
            if (!strcmp(strideType, "ASG"))
            {
                if (pdbSS.nbResidues == maxNbResidues)
                {
                    maxNbResidues += 100;
                    pdbSS.Helix    = realloc(pdbSS.Helix,    maxNbResidues * INT_SIZE);
                    pdbSS.Pihelix  = realloc(pdbSS.Pihelix,  maxNbResidues * INT_SIZE);
                    pdbSS.Helix310 = realloc(pdbSS.Helix310, maxNbResidues * INT_SIZE);
                    pdbSS.Strand   = realloc(pdbSS.Strand,   maxNbResidues * INT_SIZE);
                    pdbSS.Coil     = realloc(pdbSS.Coil,     maxNbResidues * INT_SIZE);
                    pdbSS.Turn     = realloc(pdbSS.Turn,     maxNbResidues * INT_SIZE);
                    pdbSS.Bridge   = realloc(pdbSS.Bridge,   maxNbResidues * INT_SIZE);
                }

                // Initialization of the ss counter
                switch (strideOutLine[24])
                {
                    case 'H':
                        pdbSS.Helix[pdbSS.nbResidues]    = 1;
                        pdbSS.Pihelix[pdbSS.nbResidues]  = 0;
                        pdbSS.Helix310[pdbSS.nbResidues] = 0;
                        pdbSS.Strand[pdbSS.nbResidues]   = 0;
                        pdbSS.Coil[pdbSS.nbResidues]     = 0;
                        pdbSS.Turn[pdbSS.nbResidues]     = 0;
                        pdbSS.Bridge[pdbSS.nbResidues]   = 0;
                        break;
                    case 'I':
                        pdbSS.Helix[pdbSS.nbResidues]    = 0;
                        pdbSS.Pihelix[pdbSS.nbResidues]  = 1;
                        pdbSS.Helix310[pdbSS.nbResidues] = 0;
                        pdbSS.Strand[pdbSS.nbResidues]   = 0;
                        pdbSS.Coil[pdbSS.nbResidues]     = 0;
                        pdbSS.Turn[pdbSS.nbResidues]     = 0;
                        pdbSS.Bridge[pdbSS.nbResidues]   = 0;
                        break;
                    case 'G':
                        pdbSS.Helix[pdbSS.nbResidues]    = 0;
                        pdbSS.Pihelix[pdbSS.nbResidues]  = 0;
                        pdbSS.Helix310[pdbSS.nbResidues] = 1;
                        pdbSS.Strand[pdbSS.nbResidues]   = 0;
                        pdbSS.Coil[pdbSS.nbResidues]     = 0;
                        pdbSS.Turn[pdbSS.nbResidues]     = 0;
                        pdbSS.Bridge[pdbSS.nbResidues]   = 0;
                        break;
                    case 'E':
                        pdbSS.Helix[pdbSS.nbResidues]    = 0;
                        pdbSS.Pihelix[pdbSS.nbResidues]  = 0;
                        pdbSS.Helix310[pdbSS.nbResidues] = 0;
                        pdbSS.Strand[pdbSS.nbResidues]   = 1;
                        pdbSS.Coil[pdbSS.nbResidues]     = 0;
                        pdbSS.Turn[pdbSS.nbResidues]     = 0;
                        pdbSS.Bridge[pdbSS.nbResidues]   = 0;
                        break;
                    case 'C':
                        pdbSS.Helix[pdbSS.nbResidues]    = 0;
                        pdbSS.Pihelix[pdbSS.nbResidues]  = 0;
                        pdbSS.Helix310[pdbSS.nbResidues] = 0;
                        pdbSS.Strand[pdbSS.nbResidues]   = 0;
                        pdbSS.Coil[pdbSS.nbResidues]     = 1;
                        pdbSS.Turn[pdbSS.nbResidues]     = 0;
                        pdbSS.Bridge[pdbSS.nbResidues]   = 0;
                        break;
                    case 'T':
                        pdbSS.Helix[pdbSS.nbResidues]    = 0;
                        pdbSS.Pihelix[pdbSS.nbResidues]  = 0;
                        pdbSS.Helix310[pdbSS.nbResidues] = 0;
                        pdbSS.Strand[pdbSS.nbResidues]   = 0;
                        pdbSS.Coil[pdbSS.nbResidues]     = 0;
                        pdbSS.Turn[pdbSS.nbResidues]     = 1;
                        pdbSS.Bridge[pdbSS.nbResidues]   = 0;
                        break;
                    case 'B':
                        pdbSS.Helix[pdbSS.nbResidues]    = 0;
                        pdbSS.Pihelix[pdbSS.nbResidues]  = 0;
                        pdbSS.Helix310[pdbSS.nbResidues] = 0;
                        pdbSS.Strand[pdbSS.nbResidues]   = 0;
                        pdbSS.Coil[pdbSS.nbResidues]     = 0;
                        pdbSS.Turn[pdbSS.nbResidues]     = 0;
                        pdbSS.Bridge[pdbSS.nbResidues]   = 1;
                        break;
                }

                // Incrementing the number of residues
                ++pdbSS.nbResidues;
            }
        }

        if (!feof(strideOut)) fatal_error("END_FILE", "STRIDE output");
        pdbSS.Helix    = realloc(pdbSS.Helix,    pdbSS.nbResidues * INT_SIZE);
        pdbSS.Pihelix  = realloc(pdbSS.Pihelix,  pdbSS.nbResidues * INT_SIZE);
        pdbSS.Helix310 = realloc(pdbSS.Helix310, pdbSS.nbResidues * INT_SIZE);
        pdbSS.Strand   = realloc(pdbSS.Strand,   pdbSS.nbResidues * INT_SIZE);
        pdbSS.Coil     = realloc(pdbSS.Coil,     pdbSS.nbResidues * INT_SIZE);
        pdbSS.Turn     = realloc(pdbSS.Turn,     pdbSS.nbResidues * INT_SIZE);
        pdbSS.Bridge   = realloc(pdbSS.Bridge,   pdbSS.nbResidues * INT_SIZE);
    }
    else
    {
        error("INVALID_FILE", PDBFileName);
    }

    // Closing the pipe
    pclose(strideOut);

    // Releasing memory
    free(strideExecute);

    return pdbSS;
}


secondaryStructure getSecondaryStructure(PDBListData *ENSData)
{
    // Counters
    counter resiNb, confNb;

    // Ramachandra map variables
//     unsigned short ramaMapFileNameLen;
//     char *ramaMapFileName;
//     char ramaMapChar;
//     char ramaMap[36][36];
//     FILE *ramaMapFile;

    // STRIDE executable variables
    char *strideExec = NULL;
    FILE *strideProgTest;

    // Secondary structure variables
    secondaryStructure secStr       = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0};
    secondaryStructure strideResult = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0};

    // Number of residues
    unsigned int nbResidues;

    // Misc variables
    char *PDBFileName = randomFileName(10, NULL);


    // Testing the environment variable ENSEMBLE_TOOLS
    char *ENSEMBLE_TOOLS;
    if ((ENSEMBLE_TOOLS = getenv("ENSEMBLE_TOOLS")) == NULL)
    {
        error("ENVIRONMENT", "ENSEMBLE_TOOLS");
        return secStr;
    }

    // Generating the variable strideExec
    if ((strideExec = malloc((strlen(ENSEMBLE_TOOLS) + 8) * CHAR_SIZE)) == NULL)
    {
        _clean_ss_distr(NULL, &secStr, NULL, PDBFileName, ENSEMBLE_TOOLS);
        error("MEMORY", "instance the StrideExec variable");
        return secStr;
    }

    strcpy(strideExec, ENSEMBLE_TOOLS);
    strcat(strideExec, "/stride");

    if ((strideProgTest = fopen(strideExec, "rb")) == NULL)
    {
        free(strideExec);
        _clean_ss_distr(NULL, &secStr, NULL, PDBFileName, ENSEMBLE_TOOLS);
        error("NO_FILE", strideExec);
        return secStr;
    }
    fclose(strideProgTest);

    // Ramachandran map
//     ramaMapFileNameLen = (strlen(ENSEMBLE_TOOLS) + 10);
//     ramaMapFileName = malloc (ramaMapFileNameLen * CHAR_SIZE);
//     strcpy(ramaMapFileName, ENSEMBLE_TOOLS);
//     strcat(ramaMapFileName, "/rama.map");

//     if ((ramaMapFile = fopen(ramaMapFileName, "rt")) == NULL)
//     {
//         fatal_error("NO_FILE", ramaMapFileName);
//     }
// 
// 
//     countx = 0; county = 0;
//     while ((ramaMapChar = fgetc(ramaMapFile)) != EOF)
//     {
//         if (ramaMapChar == '.' || ramaMapChar == 'h' || ramaMapChar == 'H' || ramaMapChar == 'b' || ramaMapChar == 'B' || ramaMapChar == 'L' || ramaMapChar == 'l')
//         {
//             ramaMap[countx][county] = ramaMapChar;
//             if (countx == 35)
//             {
//                 countx = 0;
//                 ++county;
//             }
//             else
//             {
//                 ++countx;
//             }
//         }
//         else if (ramaMapChar == '!' || ramaMapChar == '#')        // Comment
//         {
//             while (ramaMapChar != '\n' && ramaMapChar != EOF)    // Ignore the rest of the line
//             {
//                 ramaMapChar = fgetc(ramaMapFile);
//             }
//         }
//     }
// 
//     if (countx != 0 && county != 36) fatal_error("CORR_FILE", ramaMapFileName);

    // Number of residues
    if (!(nbResidues = getNbResidues(&(*ENSData)))) return secStr;

    // Initialization of secondary structure counters
    secStr.Helix    = calloc(nbResidues, INT_SIZE);
    secStr.Pihelix  = calloc(nbResidues, INT_SIZE);
    secStr.Helix310 = calloc(nbResidues, INT_SIZE);
    secStr.Strand   = calloc(nbResidues, INT_SIZE);
    secStr.Coil     = calloc(nbResidues, INT_SIZE);
    secStr.Turn     = calloc(nbResidues, INT_SIZE);
    secStr.Bridge   = calloc(nbResidues, INT_SIZE);


    for (confNb=0; confNb<(*ENSData).nbConfs; confNb++)
    {
        if (WritePDBFile(PDBFileName, &(*ENSData), confNb)) fatal_error("Cannot generate the structure file!", NULL);

        strideResult = runStride(strideExec, PDBFileName);
        remove(PDBFileName);

        if (strideResult.nbResidues != nbResidues)
        {
            _clean_ss_distr(NULL, &secStr, NULL, PDBFileName, ENSEMBLE_TOOLS);
            _clean_ss_distr(NULL, &strideResult, NULL, NULL, strideExec);
            error("STRIDE encountered a critical problem while treating %s", PDBFileName);
            return secStr;
        }

        for (resiNb=0; resiNb<nbResidues; resiNb++)
        {
            secStr.Helix[resiNb]    += strideResult.Helix[resiNb];
            secStr.Pihelix[resiNb]  += strideResult.Pihelix[resiNb];
            secStr.Helix310[resiNb] += strideResult.Helix310[resiNb];
            secStr.Strand[resiNb]   += strideResult.Strand[resiNb];
            secStr.Coil[resiNb]     += strideResult.Coil[resiNb];
            secStr.Turn[resiNb]     += strideResult.Turn[resiNb];
            secStr.Bridge[resiNb]   += strideResult.Bridge[resiNb];
        }

        // Releasing memory
        _clean_ss_distr(NULL, &strideResult, NULL, NULL, NULL);
    }

    secStr.nbResidues = strideResult.nbResidues;

    // Releasing memory
    ENSEMBLE_TOOLS = NULL;
    _clean_ss_distr(NULL, NULL, NULL, PDBFileName, strideExec);


    return secStr;
}

#endif