/*

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

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

#include "Include/ens.h"


enum toolsPrograms TP = __GET_INFO__;


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

    unsigned long fileSize, expFileSize;
    unsigned short nbModules;
    double effNrg;

    uint32_t nbConfs, nbAtoms, confBlockSize;
    uint32_t nbIPs, nbRestraints, runNb;
    uint32_t nbBestEns;
    unsigned short nbElements;

    FILE *ENSFile;

    /***********************************************************\
    |*                                                         *|
    |*                                                         *|
    |*   Giving information about provided arguments (files)   *|
    |*                                                         *|
    |*                                                         *|
    \***********************************************************/

    if (argc < 2)
    {
        __USAGE__
    }

    type[3] = '\0';

    for (count = 1; count < argc; count++)
    {
        if ((ENSFile = fopen(argv[count], "rb")) != NULL)
        {
            // Size of the file (Must not be larger than 4Gb!)
            fseek(ENSFile, 0, SEEK_END);
            fileSize = ftell(ENSFile);
            if (fileSize == 0)
            {
                strcpy(type, "Emp");
            }
            else
            {
                fseek(ENSFile, 0, SEEK_SET);
                fread(&type, CHAR_SIZE, 3, ENSFile);        // The 3 first characters specify the file type
            }

            if (!strcmp(type, "Inp"))        // Initial Pool file
            {
                /* A Initial Pool file type contains:
                   1. The data file type code (Inp)
                   2. The number of IP
                   3. For each IP:
                         a. The run number
                         b. The code for Compacted or Added conformers
                            - Compacted: 2 ("Start of text")
                            - Added    : 3 ("End of text")
                         c. The number of conformers
                         d. The conformer numbers
                */

				counter ipNb;
				char compact;

                // Number of IPs and expected file size
                expFileSize = 3 * CHAR_SIZE + INT32_SIZE;

                fread(&nbIPs, INT32_SIZE, 1, ENSFile);
                for (ipNb=0; ipNb<nbIPs; ipNb++)
                {
                    fread(&runNb, INT32_SIZE, 1, ENSFile);
                    fread(&compact, 1, 1, ENSFile);
                    fread(&nbConfs, INT32_SIZE, 1, ENSFile);
                    fseek(ENSFile, nbConfs * INT32_SIZE, SEEK_CUR);
                    expFileSize += CHAR_SIZE + (2 + nbConfs) * INT32_SIZE;
                }

                // Checking the consistency of the file size (this must correspond to the expected file size)
                if (fileSize != expFileSize)
                {
                    printf ("%s is a corrupted IP file type (Expected size = %lu; Real size = %lu)!\n", argv[count], expFileSize, fileSize);
                }
                else
                {
                    if (nbIPs)
                    {
	                    printf ("%s is an IP file type that contains %d initial pools\n", argv[count], nbIPs);
	            }
	            else
	            {
	                    printf ("%s is an IP file type that does not contain any initial pool\n", argv[count]);
	            }
                }
            }
            else if (!strcmp(type, "Csp"))        // CSP file
            {
                /* A CSP file contains:
                   1. The data file type code (Csp)
                   2. The number of conformers
                   3. The number of atoms per conformer
                   4. The atom headers
                   5. The coordinates (x, y, z) of the confomers in the same order than the atom headers
                */

                // Number of conformers and atoms
                fread(&nbConfs, INT32_SIZE, 1, ENSFile);
                fread(&nbAtoms, INT32_SIZE, 1, ENSFile);

                // Checking the consistency of the file size (this must correspond to the expected file size)
                expFileSize = (27 * nbAtoms + 3) * CHAR_SIZE + (2 + 3 * nbAtoms * nbConfs) * INT32_SIZE;
                if (fileSize != expFileSize)
                {
                    printf ("%s is a corrupted CSP file type (Expected size = %lu; Real size = %lu)!\n", argv[count], expFileSize, fileSize);
                }
                else
                {
                    printf ("%s is a CSP file type that contains %d conformers made of %d atoms\n", argv[count], nbConfs, nbAtoms);
                }
            }
            else if (!strcmp(type, "Ens"))        // Ensemble file
            {
                /* An ENSEMBLE file contains:
                   1. The data file type code (Ens)
                   2. The size of a double data at the time it was recorded in the PERL script
                   3. The number of conformers
                   3. The conformer numbers
                   4. The total effective energy
                   5. The score given by the C-Core of ENSEMBLE (weighted)
                   6. The number of data types (modules)
                   7. For each module:
                         a. The code of the data type
                         b. The effective energy
                         c. The target
                         d. The score given by the C-Core of ENSEMBLE (weighted)
                */

                // Size of a double data
                fread(&DOUBLE_SIZE, SHORT_SIZE, 1, ENSFile);
                if (DOUBLE_SIZE != sizeof(double))
                {
                    printf ("%s is not an Ensemble file type generated on a different machine type!\n", argv[count]);
                    exit(0);
                }

                // Number of conformers
                fread(&nbConfs, INT32_SIZE, 1, ENSFile);
                fseek(ENSFile, nbConfs*INT32_SIZE, SEEK_CUR);

                // Effective and ENSEMBLE energies
                fread(&effNrg, DOUBLE_SIZE, 1, ENSFile);

                // Number of modules
                fread(&nbModules, SHORT_SIZE, 1, ENSFile);

                // Checking the consistency of the file size (this must correspond to the expected file size)
		expFileSize = 3 * CHAR_SIZE + (nbModules + 2) * SHORT_SIZE + (nbConfs + 1) * INT32_SIZE + (2 * nbModules + 1) * DOUBLE_SIZE;
                //expFileSize = 3 * CHAR_SIZE + SHORT_SIZE + (nbConfs + 1) * INT32_SIZE + 2 * DOUBLE_SIZE + SHORT_SIZE + nbModules * (SHORT_SIZE + 3 * DOUBLE_SIZE);
                if (fileSize != expFileSize)
                {
                    printf ("%s is a corrupted Ensemble file type (Expected size = %lu; Real size = %lu)!\n", argv[count], expFileSize, fileSize);
                }
                else
                {
                    printf ("%s is an Ensemble file type that contains %u conformers and %d modules for a total effective energy of %lf\n", argv[count], nbConfs, nbModules, effNrg);
                }
            }
            else if (!strcmp(type, "Cdp"))        // Concatenated Data Pool
            {
                /* A CDP file contains:
                   1. The data file type code         (Cdp)
                   2. The data type code              (Unsigned Short)
                   3. The number of conformers        (Unsigned Integer (4 bytes))
                   4. The block size                  (Unsigned Integer (4 bytes))
                   5. The data
                */
                char *dataCode[] = {"SHIFTX", "SHIFTX_CA", "SHIFTX_CB", "SHIFTX_C", "SHIFTX_N", "SHIFTX_HA", "SHIFTX_H", "SAXS",
                                     "MRDC", "J", "NOE", "PRE", "R2", "HYDRO", "ATCUN", "ACCESS", "ACCESS_A1", "ACCESS_A2", "ACCESS_A3"};

                // The data type code
                unsigned short dataTypeCode;
                char *dataType;
                fread(&dataTypeCode, SHORT_SIZE, 1, ENSFile);
                if ((dataType = malloc((strlen(dataCode[dataTypeCode]) + 1) * CHAR_SIZE)) == NULL)
                {
                    fatal_error("MEMORY", "instance dataType variable");
                }
                strcpy(dataType, dataCode[dataTypeCode]);
                dataType[strlen(dataCode[dataTypeCode])] = '\0';

                // Number of conformers
                fread(&nbConfs, INT32_SIZE, 1, ENSFile);
                fread(&confBlockSize, INT32_SIZE, 1, ENSFile);

                // Checking the consistency of the file size (this must correspond to the expected file size)
                expFileSize = 3 * CHAR_SIZE  + SHORT_SIZE + 2 * INT32_SIZE + nbConfs * confBlockSize;
                if (fileSize != expFileSize)
                {
                    printf ("%s is a corrupted CDP file type (Expected size = %lu; Real size = %lu)!\n", argv[count], expFileSize, fileSize);
                }
                else
                {
                    printf ("%s is a CDP file type that contains the %s data of %d conformers\n", argv[count], dataType, nbConfs);
                }
            }
            else if (!strcmp(type, "Par"))        // Parameter user-defined data file
            {
                /*
                   A Parameter user-defined data file contains:
                    1. The data file type code (Par)
                    2. The number of elements in the PERL hash variable
                    3. All the elements of the PERL hash variable
                */

                // Number of elements of the PERL hash variable
                fread(&nbElements, SHORT_SIZE, 1, ENSFile);
                printf ("%s is a Parameter user-defined data file that contains %u elements.\n", argv[count], nbElements);
            }
            else if (!strcmp(type, "Bes"))        // Best file
            {
                /*
                   The best ensemble file type contains the following information:
                   0. The file type			(Character: 'Bes')
                   1. Size of a double variable		(Unsigned Short)
                   2. Number of best ensembles		(Unsigned Integer)
                      2.a. Run number				(Unsigned Long Integer)
                      2.b. Trial number				(Unsigned Long Integer)
                      2.c. Number of conformers			(Unsigned Long Integer)
                           2.c.a Conformer numbers			(Unsigned Long Integers)
                      2.d. Effective total energy		(Double Float)
                      2.e. Number of modules			(Unsigned Short)
                           2.e.a. Module code				(Unsigned Short)
                           2.e.b. Effective energy			(Double Float)
                           2.e.c. Target energy				(Double Float)
                */
                counter bestEnsNb;

                expFileSize = 3 * CHAR_SIZE + SHORT_SIZE + INT32_SIZE;

                // Size of a double variable
                fread(&DOUBLE_SIZE, SHORT_SIZE, 1, ENSFile);
                if (DOUBLE_SIZE != sizeof(double))
                {
                    printf ("%s is not a Best file type generated on a different machine type!\n", argv[count]);
                    exit(0);
                }

                // Number of best ensembles
                fread(&nbBestEns, INT32_SIZE, 1, ENSFile);

                for (bestEnsNb=0; bestEnsNb<nbBestEns; bestEnsNb++)
                {
                    fseek(ENSFile, 2 * INT32_SIZE, SEEK_CUR);       // Skipping Run number + Trial number
                    fread(&nbConfs, INT32_SIZE, 1, ENSFile);        // Number of conformers
                    fseek(ENSFile, nbConfs * INT32_SIZE, SEEK_CUR); // Skipping conformer numbers

                    fread(&effNrg, DOUBLE_SIZE, 1, ENSFile);        // Effective energy
                    fread(&nbModules, SHORT_SIZE, 1, ENSFile);      // Number of modules

                    fseek(ENSFile, nbModules * (SHORT_SIZE + 2 * DOUBLE_SIZE), SEEK_CUR);

                    expFileSize += (nbModules + 1) * SHORT_SIZE + (nbConfs + 3) * INT32_SIZE + (2 * nbModules + 1) * DOUBLE_SIZE;
                }

                // Checking the consistency of the file size (this must correspond to the expected file size)
                if (fileSize != expFileSize)
                {
                    printf ("%s is a corrupted BEST file type (Expected size = %lu; Real size = %lu)!\n", argv[count], expFileSize, fileSize);
                }
                else
                {
                    if (nbBestEns == 1)
                    {
                    	printf ("%s is a BEST file type that describes a single best ensemble, which contains %u conformers and has an energy of %.2f\n", argv[count], nbConfs, effNrg);
                    }
                    else
                    {
                        printf ("%s is a BEST file type that describes %u best ensembles. The last one has an energy of %.2f\n", argv[count], nbBestEns, effNrg);
                    }
                }
            }
            else if (!strcmp(type, "Res"))        // Rest file
            {
                /* A Restraint file contains:
                    1. The data file type code (Res)
                    2. The number of restraints        (Unsigned Short)
                    3. For each restraints
                        a. The restraint type code     (Unsigned Short)
                        b. The number of restraints    (Unsigned uint32_t (4bytes))
                        c. The restraints
                */
                fread(&nbRestraints, SHORT_SIZE, 1, ENSFile);
                printf ("%s is a RESTRAINT file that contains the restraints of %d modules.\n", argv[count], nbRestraints);
            }
            else if (!strcmp(type, "Emp"))        // Best file
            {
                /* This situation occurs if the file is empty */
                error("EMPTY", argv[count]);
            }
            else
            {
                printf ("%s has not been generated by ENSEMBLE.\n", argv[count]);
            }

            fclose(ENSFile);
        }
        else
        {
            error("NO_FILE", argv[count]);
        }
    }

    printf ("\n");
    return 0;
}