/*

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

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
**                                                                                 **
**                                                                                 **
**                                 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 -lm -o caca_map caca_map.c
*/

#include "Include/ens.h"


enum toolsPrograms TP = __CONTACT_MAP__;


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

    // Counters
    counter countx, county;

    // Provided list file
    char *PDBListFileName = NULL, *outFileName = NULL;

    // PDB files
    residueList residueNbs = {0, NULL};
    PDBListData ENSData = {0, 0, NULL, NULL};

    // Output EPS file
    char *epsOutFileName = NULL, *epsOutStdvFileName = NULL;
    char epsOutFileExt[5] = ".eps\0";
    color ldRGB = {0., 0., 0.}, udRGB = {1., 1., 1.};
    float lowerDistance = 3.5, upperDistance = 10., upStdv = 5.;

    // Ouput distances
    flaver **distances = NULL;

    // Output file
    FILE *outFile;

    /***********************************************************\
    |*                                                         *|
    |*                                                         *|
    |*            Retrieving the provided arguments            *|
    |*                                                         *|
    |*                                                         *|
    \***********************************************************/
    for (countx=1; countx<argc; countx++)
    {
        // -f flag: input list file: can be a csp file or a file with a list of PDB file pathways
        if (!strcmp(argv[countx], "-f"))
        {
            ++countx;
            if (argc>countx)
            {
                if ((PDBListFileName = malloc((strlen(argv[countx])+1) * CHAR_SIZE)) == NULL)
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("MEMORY", "create PDBListFileName variable");
                }
                strcpy(PDBListFileName, argv[countx]);
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-f");
            }
        }
        if (!strcmp(argv[countx], "-o"))
        {
            ++countx;
            if (argc>countx)
            {
                if ((outFileName = malloc((strlen(argv[countx])+1) * CHAR_SIZE)) == NULL)
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("MEMORY", "create outFileName variable");
                }
                strcpy(outFileName, argv[countx]);
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-f");
            }
        }
        // -eps flag: the eps output files
        else if (!strcmp(argv[countx], "-eps"))
        {
            ++countx;
            if (argc>countx)
            {
                if ((epsOutFileName = malloc((strlen(argv[countx])+1) * CHAR_SIZE)) == NULL)
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("MEMORY", "create pathway variable");
                }
                strcpy(epsOutFileName, argv[countx]);
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-p");
            }
        }
        // -h flag: for the help
        else if (!strcmp(argv[countx], "-h"))
        {
            _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
            __USAGE__
        }
        // -ld flag: lower distance
        else if (!strcmp(argv[countx], "-ld"))
        {
            ++countx;
            if (argc>countx)
            {
                if (!IsNumber(argv[countx]))
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("Not a correct upper distance value (%s)!", argv[countx]);
                }

                lowerDistance = atof(argv[countx]);
                if (lowerDistance < 0)
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("The specified upper distance (%s) is negative!", argv[countx]);
                }
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-ud");
            }
        }
        // -ud flag: upper distance
        else if (!strcmp(argv[countx], "-ud"))
        {
            ++countx;
            if (argc>countx)
            {
                if (!IsNumber(argv[countx]))
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("Not a correct upper distance value (%s)!", argv[countx]);
                }

                upperDistance = atof(argv[countx]);
                if (upperDistance < 0)
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("The specified lower distance (%s) is negative!", argv[countx]);
                }
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-ud");
            }
        }
        // -sd flag: upper standard deviation
        else if (!strcmp(argv[countx], "-sd"))
        {
            ++countx;
            if (argc>countx)
            {
                if (!IsNumber(argv[countx]))
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("Not a correct standard deviation value (%s)!", argv[countx]);
                }

                upStdv = atof(argv[countx]);
                if (upStdv < 0)
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("The specified standard deviation (%s) is negative!", argv[countx]);
                }
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-ud");
            }
        }
        // -colld flag: RGB color for the lower distance
        else if (!strcmp(argv[countx], "-colld"))
        {
            ++countx;
            if (argc>countx)
            {
                if (!IsNumber(argv[countx]))
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("Not a correct red color code (%s)!", argv[countx]);
                }
                ldRGB.r = atof(argv[countx]);
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-colld (red color)");
            }

            ++countx;
            if (argc>countx)
            {
                if (!IsNumber(argv[countx]))
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("Not a correct green color code (%s)!", argv[countx]);
                }
                ldRGB.g = atof(argv[countx]);
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-colld (green color)");
            }

            ++countx;
            if (argc>countx)
            {
                if (!IsNumber(argv[countx]))
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("Not a correct blue color code (%s)!", argv[countx]);
                }
                ldRGB.b = atof(argv[countx]);
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-colld (blue color)");
            }
        }
        // -colud flag: RGB color for the upper distance
        else if (!strcmp(argv[countx], "-colud"))
        {
            ++countx;
            if (argc>countx)
            {
                if (!IsNumber(argv[countx]))
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("Not a correct red color code (%s)!", argv[countx]);
                }
                udRGB.r = atof(argv[countx]);
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-colud (red color)");
            }

            ++countx;
            if (argc>countx)
            {
                if (!IsNumber(argv[countx]))
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("Not a correct green color code (%s)!", argv[countx]);
                }
                udRGB.g = atof(argv[countx]);
            }
            else
            {
                fatal_error("NO_ARGUMENT_FLAG", "-colud (green color)");
            }

            ++countx;
            if (argc>countx)
            {
                if (!IsNumber(argv[countx]))
                {
                    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                    fatal_error("Not a correct blue color code (%s)!", argv[countx]);
                }
                udRGB.b = atof(argv[countx]);
            }
            else
            {
                _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
                fatal_error("NO_ARGUMENT_FLAG", "-colud (blue color)");
            }
        }
    }

    // Verification of arguments coherence
    if (PDBListFileName == NULL)
    {
        _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
        __USAGE__
    }

    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 (epsOutFileName == NULL)        // Optionnal output file
    {
        epsOutFileName = calloc(strlen(PDBListFileName) + 8, CHAR_SIZE);
        strcpy(epsOutFileName, PDBListFileName);
        
        for (countx=strlen(PDBListFileName), county=0; countx>0; county++)
        {
            --countx;
            if (PDBListFileName[countx] == '/')
            {
                strncpy(&epsOutFileName[countx+1], "./caca_", 7);
                break;
            }
            else
            {
                epsOutFileName[countx+7] = PDBListFileName[countx];
                if (countx == 0)
                {
                    strncpy(&epsOutFileName[0], "./caca_", 7);
                }
            }
        }

        if (strlen(PDBListFileName)>3 && PDBListFileName[strlen(PDBListFileName)-4] == '.' && PDBListFileName[strlen(PDBListFileName)-3] == 'e' && PDBListFileName[strlen(PDBListFileName)-2] == 'n' && PDBListFileName[strlen(PDBListFileName)-1] == 's')
        {
            epsOutFileName[strlen(epsOutFileName)-2] = 'p';
        }
        else
        {
            epsOutFileName = realloc(epsOutFileName, (strlen(epsOutFileName) + 5) * CHAR_SIZE);
            strcpy(&epsOutFileName[strlen(epsOutFileName)], ".eps");
        }
    }
    else
    {
        for (countx=0; countx<4; countx++)
        {
            if (epsOutFileName[strlen(epsOutFileName)-countx-1] != epsOutFileExt[3-countx])
            {
                epsOutFileName = realloc(epsOutFileName, strlen(epsOutFileName) * CHAR_SIZE + 5);
                strcpy(&epsOutFileName[strlen(epsOutFileName)], epsOutFileExt);
                break;
            }
        }
    }

    if ((epsOutStdvFileName = malloc((strlen(epsOutFileName) + 7) * CHAR_SIZE)) == NULL)
    {
        _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
        fatal_error("MEMORY", "instance epsOutStdvFileName variable");
    }
    strcpy(epsOutStdvFileName, epsOutFileName);
    strcpy(&epsOutStdvFileName[strlen(epsOutFileName)-4], "_stdv.eps");

    // Of course...
    if (lowerDistance >= upperDistance)
    {
        _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
        fatal_error("The upper distance must be larger than the lower distance!", NULL);
    }

    /***********************************************************\
    |*                                                         *|
    |*                                                         *|
    |*        Getting Ca coordinates for each PDB file         *|
    |*                                                         *|
    |*                                                         *|
    \***********************************************************/
    // Recording the CA coordinates of all atoms of the PDB list file
    if (getAtomCoords(&ENSData, PDBListFileName, "CA"))
    {
            _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
           fatal_error("A problem occured while recording coordinates from the %s ENSEMBLE file.", PDBListFileName);
    }

    // Getting the residue numbers
    getResidueNumbers(&residueNbs, &ENSData);
    if (!residueNbs.nb)
    {
        _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);
        fatal_error("A problem occured while recording residue numbers from atom headers.", argv[1]);
    }

    /***********************************************************\
    |*                                                         *|
    |*                                                         *|
    |*              Measuring all CA-CA distances              *|
    |*                  Creating the EPS plot                  *|
    |*                                                         *|
    |*                                                         *|
    \***********************************************************/
    caca_map(&distances, &ENSData, &residueNbs, epsOutFileName, epsOutStdvFileName, lowerDistance, upperDistance, upStdv, &ldRGB, &udRGB);

    for (countx=0; countx<residueNbs.nb-1; countx++)
    {
        for (county=countx+1; county<residueNbs.nb; county++)
        {
            fprintf(outFile, "Ca_%d-Ca_%d:\t%6.2f +/- %6.2f\n", residueNbs.nbs[countx], residueNbs.nbs[county], distances[countx][county].average, distances[countx][county].stdv);
        }
    }


    // Releasing memory
    fclose(outFile);
    _cleanMap(&ENSData, &residueNbs, distances, PDBListFileName, outFileName, epsOutFileName, epsOutStdvFileName);


    return 0;
}