/*

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

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
**                                                                                 **
**                                                                                 **
**                                 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 extract_csp extract_csp.c
*/

#include "Include/ens.h"


enum toolsPrograms TP = __EXTRACT_CSP__;


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

    const char delimiters[] = " -";
    char listOK = FALSE, toFlag = FALSE;
    char fflag = FALSE, pflag = FALSE, xflag = FALSE, sflag = FALSE, lflag = FALSE;
    char *token = NULL;
    char *pathway = NULL, *cspFileName = NULL, *prefix = NULL;

    unsigned int nbDoublons = 0;
    unsigned int start = 1;
    unsigned int extractListSize = 0;
    unsigned int limits[2];

    mode_t processMask;

    confList confNbsList = {0, NULL};

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

    /***********************************************************\
    |*                                                         *|
    |*                                                         *|
    |*                  Retrieving  arguments                  *|
    |*                                                         *|
    |*                                                         *|
    \***********************************************************/
    if (argc < 2)
    {
        __USAGE__
    }

    for (count=1; count<argc; count++)
    {
        if (!strcmp(argv[count], "-f"))
        {
            if (fflag)
            {
                _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                fatal_error("DOUBLE_FLAG", argv[count]);
            }

            ++count;
            if (argc>count)
            {
                if ((cspFileName = malloc((strlen(argv[count]) + 1) * CHAR_SIZE)) == NULL)
                {
                    _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                    fatal_error("MEMORY", "create cspFileName variable");
                }
                strcpy(cspFileName, argv[count]);
            }
            else
            {
                fatal_error("NO_ARGUMENT_FLAG", "-f");
            }

            listOK = FALSE;
            fflag = TRUE;
        }
        else if (!strcmp(argv[count], "-p"))
        {
            if (pflag)
            {
                _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                fatal_error("DOUBLE_FLAG", argv[count]);
            }

            ++count;
            if (argc>count)
            {
                if ((pathway = malloc((strlen(argv[count]) + 1) * CHAR_SIZE)) == NULL)
                {
                    _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                    fatal_error("MEMORY", "create pathway variable");
                }
                strcpy(pathway, argv[count]);
            }
            else
            {
                fatal_error("NO_ARGUMENT_FLAG", "-f");
            }

            listOK = FALSE;
            pflag = TRUE;
        }
        else if (!strcmp(argv[count], "-s"))
        {
            if (sflag)
            {
                _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                fatal_error("DOUBLE_FLAG", argv[count]);
            }

            ++count;
            if (argc>count)
            {
                if (isInt(argv[count]) && atoi(argv[count])>0)
                {
                    sflag = TRUE;
                    start = atoi(argv[count]);
                }
                else
                {
                    _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                    fatal_error("WRONG_ARGUMENT", argv[count]);
                }
            }

            listOK = FALSE;
            sflag = TRUE;
        }
        else if (!strcmp(argv[count], "-x"))
        {
            if (xflag)
            {
                _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                fatal_error("DOUBLE_FLAG", argv[count]);
            }

            ++count;
            if (argc>count)
            {
                if ((prefix = malloc((strlen(argv[count]) + 1) * CHAR_SIZE)) == NULL)
                {
                    _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                    fatal_error("MEMORY", "create prefix variable");
                }
                strcpy(prefix, argv[count]);
            }
            else
            {
                fatal_error("NO_ARGUMENT_FLAG", "-x");
            }

            listOK = FALSE;
            xflag = TRUE;
        }
        else if (!strcmp(argv[count], "-l"))
        {
            if (lflag)
            {
                _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                fatal_error("DOUBLE_FLAG", argv[count]);
            }

            listOK = TRUE;
            lflag = TRUE;
        }
        else if (!strcmp(argv[count], "-"))
        {
            if (!listOK || toFlag)
            {
                _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                fatal_error("WRONG_FLAG", argv[count]);
            }
            toFlag = TRUE;
        }
        else if (listOK)
        {
            if (confNbsList.nb == extractListSize)
            {
                extractListSize += 10;
                if ((confNbsList.confNb = realloc(confNbsList.confNb, extractListSize * INT_SIZE)) == NULL)
                {
                    _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                    fatal_error("MEMORY", "re-instance confNbsList.confNb variable");
                }
            }

            if (isInt(argv[count]))
            {
                //printf("%s is an INTEGER!\n", argv[count]);
                if (toFlag || argv[count][0]=='-')
                {
                    if (!confNbsList.nb)    // Case "-l -x" => This is equivalent to "-l 1-x"
                    {
                        limits[0] = 1;
                        limits[1] = (int)fabs(atoi(argv[count]));
                    }
                    else            // Case "x- y" or "y- x" or "x -y" 
                    {
                        limits[0] = min(confNbsList.confNb[confNbsList.nb-1], (int)fabs(atoi(argv[count])));
                        limits[1] = max(confNbsList.confNb[confNbsList.nb-1], (int)fabs(atoi(argv[count])));
                    }

                    //printf("\tFROM %d TO %d\n", limits[0], limits[1]);

                    if (extractListSize-confNbsList.nb < limits[1]-limits[0])
                    {
                        extractListSize += limits[1] - limits[0];
                        if ((confNbsList.confNb = realloc(confNbsList.confNb, extractListSize * INT_SIZE)) == NULL)
                        {
                            _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                            fatal_error("MEMORY", "re-instance confNbsList.confNb variable");
                        }
                    }

                    --confNbsList.nb;
                    for (i=limits[0]; i<=limits[1]; i++)
                    {
                        confNbsList.confNb[confNbsList.nb] = i;
                        ++confNbsList.nb;
                    }

                    toFlag = FALSE;
                }
                else
                {
                    confNbsList.confNb[confNbsList.nb] = atoi(argv[count]);
                    ++confNbsList.nb;
                }
            }
            else    // Case "x-y" or "x- y" or "x -y"
            {
                token = strtok(argv[count], delimiters);
                if (isInt(token))
                {
                    limits[0] = atoi(token);
                    token = strtok(NULL, delimiters);

                    if (token == NULL)    // Case "x- y"
                    {
                        if (confNbsList.nb == extractListSize)
                        {
                            extractListSize += 1;
                            if ((confNbsList.confNb = realloc(confNbsList.confNb, extractListSize * INT_SIZE)) == NULL)
                            {
                                _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                                fatal_error("MEMORY", "re-instance confNbsList.confNb variable");
                            }
                        }

                        confNbsList.confNb[confNbsList.nb] = limits[0];
                        ++confNbsList.nb;

                        toFlag = TRUE;
                    }
                    else if (isInt(token))    // Case "x-y"
                    {
                        limits[1] = atoi(token);

                        qsort(limits, 2, INT_SIZE, sort);

                        if (extractListSize-confNbsList.nb < limits[1]-limits[0]+1)
                        {
                            extractListSize += limits[1] - limits[0] + 1;
                            if ((confNbsList.confNb = realloc(confNbsList.confNb, extractListSize * INT_SIZE)) == NULL)
                            {
                                _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
                                fatal_error("MEMORY", "re-instance confNbsList.confNb variable");
                            }
                        }

                        for (i=limits[0]; i<=limits[1]; i++)
                        {
                            confNbsList.confNb[confNbsList.nb] = i;
                            ++confNbsList.nb;
                        }
                    }
                    else
                    {
                        fatal_error("INVALID_ARGUMENT", argv[count]);
                    }
                }
                else
                {
                    fatal_error("INVALID_ARGUMENT", argv[count]);
                }
            }
        }
        else
        {
            _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
            fatal_error("WRONG_FLAG", argv[count]);
        }
    }

    // Checking whether a pathway has been provided
    if (pathway != NULL)
    {
        processMask = umask(0);
        mkdir(pathway, S_IRWXU);

        if (errno==EACCES)
        {
            _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
            printf ("\n\tCannot create the directory %s (Write permission is denied)!\n\n", pathway);
            exit(EACCES);
        }
        else if (errno==EROFS)
        {
            _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
            printf ("\n\tThe parent directory of %s is on a read-only file system and cannot be modified!\n\n", pathway);
            exit(EROFS);
        }
    }
    else
    {
        if ((pathway = malloc(3 * CHAR_SIZE)) == NULL)
        {
            _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
            fatal_error("MEMORY", "instance pathway variable");
        }
        strcpy(pathway, "./");
    }

    if (listOK && (!confNbsList.nb))
    {
        warning("NO_ARGUMENT_FLAG", "-l");
        listOK = FALSE;
        free(confNbsList.confNb);
        confNbsList.confNb = NULL;
    }

    // Checking whether a input file has been submitted
    if (cspFileName == NULL)
    {
        _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
        __USAGE__;
    }

    // Checking whether a prefix has been provided
    if (prefix == NULL)
    {
        if ((prefix = malloc(6 * CHAR_SIZE)) == NULL)
        {
            _cleanExtractCSP(NULL, NULL, pathway, cspFileName, prefix, token);
            fatal_error("MEMORY", "instance prefix variable");
        }
        strcpy(prefix, "conf_");
    }

    /***********************************************************\
    |*                                                         *|
    |*                                                         *|
    |*          Getting coordinates of each PDB file           *|
    |*                                                         *|
    |*                                                         *|
    \***********************************************************/
    if (lflag)
    {
        qsort(confNbsList.confNb, confNbsList.nb, INT_SIZE, sort);

        if (confNbsList.confNb[0] < 1)
        {
            _cleanExtractCSP(NULL, &confNbsList, pathway, cspFileName, prefix, token);
            fatal_error("Illicit conformer number (It must start from 1).", NULL);
        }

        // Ignoring nbDoublons
        limits[0] = confNbsList.confNb[0];
        for (count=1; count<confNbsList.nb; count++)
        {
            nbDoublons = 0;
            for (i=count; i<confNbsList.nb; i++)
            {
                if (confNbsList.confNb[i] == limits[0])
                {
                    ++nbDoublons;
                }
                else
                {
                    limits[0] = confNbsList.confNb[i];
                    break;
                }
            }

            if (nbDoublons)
            {
                for (i=count; i<confNbsList.nb; i++) confNbsList.confNb[i] = confNbsList.confNb[i+nbDoublons];
                confNbsList.nb -= nbDoublons;
            }
        }

        if ((confNbsList.confNb = realloc(confNbsList.confNb, confNbsList.nb * INT_SIZE)) == NULL)
        {
            _cleanExtractCSP(NULL, &confNbsList, pathway, cspFileName, prefix, token);
            fatal_error("MEMORY", "re-instance confNbsList.confNb variable");
        }

        if (sflag)
        {
            i = confNbsList.confNb[0];
            for (count=0; count<confNbsList.nb; count++) confNbsList.confNb[count] += start - i;
        }

        // Indicating the number of structures that will be extracted
        printf ("%d structural files will be created.\n", confNbsList.nb);
    }
    else
    {
        // Simple indication that all structures will be extracted
        printf ("All structural files will be extracted.\n");
    }

    // Recording the specified pdb files and calculating the Rg
    if (getCoords(&ENSData, cspFileName, &confNbsList))
    {
        _cleanExtractCSP(&ENSData, &confNbsList, pathway, cspFileName, prefix, token);
        fatal_error("A problem occured while recording coordinates from the %s list file.", cspFileName);
    }

    /***********************************************************\
    |*                                                         *|
    |*                                                         *|
    |*                Structural files creation                *|
    |*                                                         *|
    |*                                                         *|
    \***********************************************************/
    if (!extractCSP(&ENSData, &confNbsList, pathway, prefix, start)) printf ("DONE\n\n");


    // Releasing memory
    _cleanExtractCSP(&ENSData, &confNbsList, pathway, cspFileName, prefix, token);


    return 0;
}