/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
**                                                                                 **
**                                                                                 **
**                                                       **                        **
**                                                       **                        **
**                       *********                       **                        **
**        **********    **********    ***        ***     **                        **
**        **********    **            ****      ****     **      **********        **
**        **            **            **  **  **  **     **      **********        **
**        **            ********      **  **  **  **     **      **                **
**        ******         ********     **    **    **     **      **                **
**        ******               ***    **    **    **     **************            **
**        **     ***     **    **********         **     **************            **
**        **     ***    *****************        ********        **                **
**        ***********   *********     **         *********       **                **
**        ***********    **    **     **         ***    **       **********        **
**               **  **  **    ******            **     **       **********        **
**               **  **  **    ******            ********                          **
**               **    * **    **                *********                         **
**               **    * **    **                **      **                        **
**               **     ***    **********        **      **                        **
**               **     ***    **********        **********                        **
**                                               *********                         **
**                                                                                 **
**                                                                                 **
**                          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 __CSP_HEADER__
#define __CSP_HEADER__


void _cleanExtractCSP(PDBListData *ENSData, confList *confNbsList, char *pathway, char *cspFileName, char *prefix, char *token)
{
    _cleanPDB(ENSData);

    if (confNbsList != NULL && (*confNbsList).confNb != NULL)
    {
        free((*confNbsList).confNb);
        (*confNbsList).confNb = NULL;
    }
    
    free(pathway); pathway = NULL;
    free(cspFileName); cspFileName = NULL;
    free(prefix); prefix = NULL;
    free(token); token = NULL;
}


void _cleanMakeCSP(int32Coordinates *intAtomCoords, char **atomHeaders, char *PDBListFileName, char *outFileName, uint32_t nbAtoms)
{
    counter count;

    free(intAtomCoords); intAtomCoords = NULL;

    if (atomHeaders != NULL)
    {
        for (count=0; count<nbAtoms; count++)
        {
            free(atomHeaders[count]);
            atomHeaders[count] = NULL;
        }
        free(atomHeaders);
    }

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


void _cleanCombineCSP(char *cspOutFileName, char **cspInpFileNames, unsigned int nbInpFiles)
{
    counter count;

    free(cspOutFileName); cspOutFileName = NULL;

    for (count=0; count<nbInpFiles; count++)
    {
        free(cspInpFileNames[count]);
        cspInpFileNames[count] = NULL;
    }
    free(cspInpFileNames); cspInpFileNames = NULL;
}


void _cleanCombineCDP(char *cdpOutFileName, char **cdpInpFileNames, unsigned int nbInpFiles)
{
    counter count;

    free(cdpOutFileName); cdpOutFileName = NULL;

    for (count=0; count<nbInpFiles; count++)
    {
        free(cdpInpFileNames[count]);
        cdpInpFileNames[count] = NULL;
    }
    free(cdpInpFileNames); cdpInpFileNames = NULL;
}


int extractCSP(PDBListData *ENSData, confList *confNbsList, char *dirWhere, char *prefix, unsigned int start)
{
    counter confNb, atomNb;
    char pdbFileName[MAX_PATHWAY_LEN];
    FILE *pdbFile;

    for (confNb=0; confNb<(*ENSData).nbConfs; confNb++)
    {
        if ((*confNbsList).confNb != NULL)
        {
            sprintf(pdbFileName, "%s/%s%u.pdb", dirWhere, prefix, (*confNbsList).confNb[confNb]);
        }
        else
        {
            sprintf(pdbFileName, "%s/%s%u.pdb", dirWhere, prefix, confNb+start);
        }

        if ((pdbFile = fopen(pdbFileName, "wt")) == NULL)
        {
            printf("Impossible to generate the conformer number %d!\n", confNb);
            return 1;
        }
        else
        {
            for (atomNb=0; atomNb<(*ENSData).nbAtoms; atomNb++)
            {
                fprintf(pdbFile, "%s   %8.3f%8.3f%8.3f  1.00  0.00\n", (*ENSData).atomHeaders[atomNb], (*ENSData).atomCoords[confNb][atomNb].x, (*ENSData).atomCoords[confNb][atomNb].y, (*ENSData).atomCoords[confNb][atomNb].z);
            }
            fprintf(pdbFile, "END\n");
            fclose(pdbFile);
        }
    }

    return 0;
}


int combineCSP(char *CSPOutFileName, char **CSPInpFileNames, unsigned int nbCSPInpFileNames)
{
    counter cspFileNb, atomNb, confNb;
    uint32_t nbConfs, nbAtoms = 0, readNbAtoms, totalNbConfs = 0;

    long confCoordsLen = 0;

    char (*atomHeaders)[28] = NULL;
    char *confCoordsChar = NULL;
    char atomHeader[28] = {'\0'};
    char fileType[4] = {'\0'};

    FILE *ENSOutFile, *ENSInpFile;

    // Opening and preparing the output file
    if ((ENSOutFile = fopen(CSPOutFileName, "wb")) == NULL)
    {
        printf("Impossible to open %s!\n", CSPOutFileName);
        return 1;
    }

    fputs("Csp", ENSOutFile);
    fwrite(&nbCSPInpFileNames, INT32_SIZE, 1, ENSOutFile);        // This value will be modified at the very end of the program

    for (cspFileNb=0; cspFileNb<nbCSPInpFileNames; cspFileNb++)
    {
        printf("\tReading %s\n", CSPInpFileNames[cspFileNb]);
        if ((ENSInpFile = fopen(CSPInpFileNames[cspFileNb], "rb")) == NULL)
        {
            error("Impossible to open %s!\n", CSPInpFileNames[cspFileNb]);
            return 1;
        }

        // Reading in the file type
        fread(&fileType, CHAR_SIZE, 3, ENSInpFile);
        if (strcmp(fileType, "Csp"))
        {
            fclose(ENSInpFile);
            fclose(ENSOutFile);
            error("CSP_FILE", CSPInpFileNames[cspFileNb]);
            return 1;
        }

        // Reading in the number of conformers
        fread(&nbConfs, INT32_SIZE, 1, ENSInpFile);


        // Reading in the number of atoms
        fread(&readNbAtoms, INT32_SIZE, 1, ENSInpFile);
        if (cspFileNb)
        {
            if (readNbAtoms!=nbAtoms)
            {
                fclose(ENSInpFile);
                fclose(ENSOutFile);
                error("The file %s does not contain the same number of atoms as the model!\n", CSPInpFileNames[cspFileNb]);
                return 1;
            }
        }
        else
        {
            nbAtoms = readNbAtoms;

            confCoordsLen  = 3 * INT32_SIZE * nbAtoms;
            confCoordsChar = malloc((confCoordsLen+1)*CHAR_SIZE);
            confCoordsChar[confCoordsLen] = '\0';

            fwrite(&nbAtoms, INT32_SIZE, 1, ENSOutFile);
        }

        // Reading headers
        if (cspFileNb)
        {
            // Headers of other CSP are compared with the model
            for (atomNb=0; atomNb<nbAtoms; atomNb++)
            {
                fread(&atomHeader, CHAR_SIZE, 27, ENSInpFile);
                if (strcmp(atomHeader, atomHeaders[atomNb]))
                {
                    fclose(ENSInpFile);
                    fclose(ENSOutFile);
                    error("The file %s does not contain the same headers as the model!\n", CSPInpFileNames[cspFileNb]);
                    return 1;
                }
            }
        }
        else
        {
            // Headers of the first CSP are recorded as model
            if ((atomHeaders = malloc(nbAtoms*sizeof(*atomHeaders))) == NULL)
            {
                fclose(ENSInpFile);
                fclose(ENSOutFile);
                error("MEMORY", "instance atomHeaders variable");
                return 1;
            }

            
            for (atomNb=0; atomNb<nbAtoms; atomNb++)
            {
                fread(atomHeaders[atomNb], CHAR_SIZE, 27, ENSInpFile);
                atomHeaders[atomNb][27] = '\0';

                // Writing the header in the output file
                fputs(atomHeaders[atomNb], ENSOutFile);
            }
        }


        // Writing coordinates
        for (confNb=0; confNb<nbConfs; confNb++)
        {
            fread(confCoordsChar, CHAR_SIZE, confCoordsLen, ENSInpFile);
            fwrite(confCoordsChar, CHAR_SIZE, confCoordsLen, ENSOutFile);
        }

        fread(confCoordsChar, CHAR_SIZE, 1, ENSInpFile);      // Needs to be read to check the end of the file
        if(!feof(ENSInpFile))
        {
            fclose(ENSInpFile);
            fclose(ENSOutFile);
            error("The file %s is corrupted!", CSPInpFileNames[cspFileNb]);
            return 1;
        }

        fclose(ENSInpFile);
        totalNbConfs += nbConfs;
    }

    // Modifying the total number of conformers
    fseek(ENSOutFile, 3 * CHAR_SIZE, SEEK_SET);
    fwrite(&totalNbConfs, INT32_SIZE, 1, ENSOutFile);

    // Closing the output file
    fclose(ENSOutFile);

    return 0;
}


int combineCDP(char *CDPOutFileName, char **CDPInpFileNames, unsigned int nbCDPInpFileNames)
{
    counter cdpFileNb, confNb;
    uint32_t nbConfs, totalNbConfs = 0;
    uint32_t tmpConfBlockSize, confBlockSize = 0;

    unsigned short tmpDataTypeCode, dataTypeCode = 0;

    char *confData = NULL;
    char fileType[4] = {'\0'};


    FILE *ENSOutFile, *ENSInpFile;

    // Opening and preparing the output file
    if ((ENSOutFile = fopen(CDPOutFileName, "wb")) == NULL)
    {
        error("Impossible to open %s!\n", CDPOutFileName);
        return 1;
    }

    // Initializing the output file
    fputs("Cdp", ENSOutFile);
    fwrite(&dataTypeCode, SHORT_SIZE, 1, ENSOutFile);         // Data code
    fwrite(&totalNbConfs, INT32_SIZE, 1, ENSOutFile);         // Number of conformers
    fwrite(&confBlockSize, INT32_SIZE, 1, ENSOutFile);        // Data bloc size


    for (cdpFileNb=0; cdpFileNb<nbCDPInpFileNames; cdpFileNb++)
    {
        printf("\tReading %s\n", CDPInpFileNames[cdpFileNb]);
        if ((ENSInpFile = fopen(CDPInpFileNames[cdpFileNb], "rb")) == NULL)
        {
            error("Impossible to open %s!\n", CDPInpFileNames[cdpFileNb]);
            return 1;
        }

        // Reading in the file type
        fread(&fileType, CHAR_SIZE, 3, ENSInpFile);
        if (strcmp(fileType, "Cdp"))
        {
            fclose(ENSInpFile);
            fclose(ENSOutFile);
            error("CDP_FILE", CDPInpFileNames[cdpFileNb]);
            return 1;
        }

        // Reading in the data type
        fread(&tmpDataTypeCode, SHORT_SIZE, 1, ENSInpFile);
        if (cdpFileNb)
        {
            if (tmpDataTypeCode != dataTypeCode)
            {
                error("Data contained in %s are different from the model!", CDPInpFileNames[cdpFileNb]);
                return 1;
            }
        }
        else
        {
            dataTypeCode = tmpDataTypeCode;
        }

        // Reading in the number of conformers
        fread(&nbConfs, INT32_SIZE, 1, ENSInpFile);


        // Reading in the data bloc size
        fread(&tmpConfBlockSize, INT32_SIZE, 1, ENSInpFile);
        if (cdpFileNb)
        {
            if (tmpConfBlockSize != confBlockSize)
            {
                error("Data bloc size of %s is different from the model!", CDPInpFileNames[cdpFileNb]);
                return 1;
            }
        }
        else
        {
            confBlockSize = tmpConfBlockSize;
            confData = malloc(confBlockSize * CHAR_SIZE);
        }

        // Writing data
        for (confNb=0; confNb<nbConfs; confNb++)
        {
            fread(confData, CHAR_SIZE, confBlockSize, ENSInpFile);
            fwrite(confData, CHAR_SIZE, confBlockSize, ENSOutFile);
        }

        fread(confData, CHAR_SIZE, 1, ENSInpFile);    // Needs to be read to check the end of the file
        if(!feof(ENSInpFile))
        {
            fclose(ENSInpFile);
            fclose(ENSOutFile);

            free(confData); confData = NULL;

            error("The file %s is corrupted!", CDPInpFileNames[cdpFileNb]);
            return 1;
        }

        fclose(ENSInpFile);
        totalNbConfs += nbConfs;
    }

    // Modifying the data type total number of conformers
    fseek(ENSOutFile, 3 * CHAR_SIZE, SEEK_SET);
    fwrite(&dataTypeCode, SHORT_SIZE, 1, ENSOutFile);
    fwrite(&totalNbConfs, INT32_SIZE, 1, ENSOutFile);
    fwrite(&confBlockSize, INT32_SIZE, 1, ENSOutFile);

    // Releasing memory
    free(confData); confData = NULL;

    // Closing the output file
    fclose(ENSOutFile);

    return 0;
}


#endif