#################################################################################################
#
# Script
#
#   ibisAnalysisEnvSetUp.sh
#
# Funzionalita'
#
#   Costruisce l'ambiente necessario alle elaborazioni dei dati ibis
#
# Parametri
#
#   listOfScwsAbsolutePath: path assoluto del file di testo delle science window da elaborare
#   workingDirectory:       nome della working directory associata alla elaborazione
#   numberOfParallelRuns:   numero di run parallele previste per la stessa elaborazione. Nel
#                           caso in cui il file delle science window non contenga delimitatori
#                           di run, puo' essere un qualunque valore maggiore di 0, altrimenti
#                           deve coincidere con il numero di tali delimitatori. In ogni caso
#                           deve essere minore o uguale al numero di core assegnato al 
#                           container
# Valore restituito
#   0 (SUCCESS): se la costruzione termina correttamente
#   1 (FAILURE): altrimenti
#
#################################################################################################

#################################################################################################
#
# Predispone l'ambiente di esecuzione
#
#################################################################################################

#
# Attenzione!!!!
#    la variabile "integralScriptsDevPath" e' valorizzata all'interno del file "/etc/profile"
#    con il path assoluto della directory che contiene gli script che implementano le diverse
#    modalita' di elaborazione
#

# Importa la definizione delle costanti simboliche condivise tra le implementazioni delle
# diverse modalita' di elaborazione
source $integralScriptsDevPath/scripts/sharedScriptsAndFunc/sharedSymbolicConstantsSetup.sh

# Importa la definizione delle costanti simboliche specifiche dell'implementazione di questa
# modalita'
source $integralScriptsDevPath/scripts/ibisAnalysisEnvSetUp/symbolicConstantsSetup.sh

# Importa la definizione delle utilities condivise dalle implementazioni delle diverse
# modalita' di elaborazione
source $SHARED_UTILITIES

# Importa la definizione delle funzioni specifiche dell'implementazione di questa
# modalita' di elaborazione
source $FUNCTIONS

# Importa la definizione delle utilities specifiche dell'implementazione di questa
# modalita' di elaborazione
source $UTILITIES

# Importa la definizione dei messaggi di errore specifici dell'implementazione di questa
# modalita' di elaborazione
source $ERROR_MESSAGES

# Importa la definizione dei messaggi di log specifici dell'implementazione di questa
# modalita' di elaborazione
source $LOG_MESSAGES

# Importa la definizione dei messaggi di log condivisi tra le implementazioni delle
# diverse modalita' di elaborazione
source $SHARED_LOG_MESSAGES

# Controlla se esiste un file con lo stesso path assoluto della main directory
checkFileExistence $PATH_OF_OSA_MAIN_DIRECTORY

if test $? -eq $SUCCESS
then
   # In caso di risposta positiva, segnala la condizione d'errore e termina con fallimento
   echo -e "${ERROR_MESSAGES_ARRAY[ERR_OSA_ANALYSIS_DIRECTORY]}"\
           "$PATH_OF_OSA_MAIN_DIRECTORY"
		   
   exit $FAILURE
fi

#
# Debug
#
#   Verificare:
#
#   il funzionamento dello script in presenza di errori
#      - se esiste un file con lo stesso path assoluto della main director ->
#        visualizza un opportuno messaggio di errore e termina con fallimento
#      - altrimenti -> continua
#
# exit
#

# Controlla se la main directory gia' esiste
checkDirectoryExistence $PATH_OF_OSA_MAIN_DIRECTORY


if test $? -eq $FAILURE
then
   # In caso di risposta negativa la crea
   mkdir $PATH_OF_OSA_MAIN_DIRECTORY
fi

#
# Debug
#
#   Verificare: 
#
#   l'esistenza della main directory              
#      - la main directory gia' esiste -> continua
#      - altrimenti -> crea la main directory e continua
#
# echo -e "\n######### Debug - Inizio ############################################\n"
#
# ls /home/integraldevelopment/integralScriptsDevelopment
#
# echo -e "\n######### Debug - Fine ##############################################\n"
#
# exit
#

# Controlla se il numero dei parametri e' corretto
checkNoOfParameters $# 3

if test $? -eq $FAILURE
then
   # In caso di risposta negativa, segnala la condizione d'errore e termina con fallimento
   echo -e ${ERROR_MESSAGES_ARRAY[ERR_PARAMETERS_NUMBER]}
   
   exit $FAILURE
fi

#
# Debug
#   
#   Verificare:
#
#   il funzionamento dello script in presenza di errori
#      - se il numero dei parametri e' corretto -> continua
#      - altrimenti -> visualizza un opportuno messaggio di errore e termina con fallimento
#
# exit
#

# Inizializza le variabili mnemoniche per i parametri
listOfScwsAbsolutePath=$1
workingDirectory=$2
numberOfParallelRuns=$3

#
# Debug
#
#    Verificare:
#        
#    la corretta inizializzazione di parametri        
#               
# echo -e "\n######### Debug - Inizio ############################################\n"
#
# echo "listOfScwsAbsolutePath: $listOfScwsAbsolutePath"
# echo "workingDirectory: $workingDirectory"
# echo "numberOfParallelRuns: $numberOfParallelRuns"
#
# echo -e "\n######### Debug - Fine ##############################################\n"
#
# exit
#

# Controlla se il file delle science window da elaborare esiste
checkFileEmptiness $listOfScwsAbsolutePath

if test $? -eq $FAILURE
then  
   # In caso di risposta negativa segnala la condizione d'errore e termina con fallimento
   echo "${ERROR_MESSAGES_ARRAY[ERR_NON_EXISTENT_LIST_OF_SCW]}"\
        "$listOfScwsAbsolutePath"
		
   exit $FAILURE
fi

#
# Debug
#
#   Verificare:
#   
#   il funzionamento dello script in presenza di errori
#      - il file delle scw esiste e non e' vuoto -> continua
#      - il file delle scw esiste ed e' vuoto -> visualizza un opportuno messaggio
#                                                di errore e termina con fallimento
#      - il file delle scw non esiste -> visualizza un opportuno messaggio
#                                        di errore e termina con fallimento
#

# Conta il numero di delimitatori di run all'interno del file delle scw da elaborare
countRunDelimiters $listOfScwsAbsolutePath

numberOfRunDelimiters=$?

#
# Debug
#
#   Verificare:
#      il corretto conteggio dei delimitatori di run all'interno del file delle scw da elaborare:
#
# echo -e "\n######### Debug - Inizio ############################################\n"
# 
# echo "numberOfRunDelimiters: $numberOfRunDelimiters"
#
# echo -e "\n######### Debug - Fine ##############################################\n"
#
# exit        
#

#
# Debug
#
#   Verificare:
#   
#   il funzionamento dello script in presenza di errori:
#      - la prima riga del file delle science window e' un delimitatore di run -> visualizza un opportuno messaggio
#                                                                                 di errore e termina con fallimento
#      - l'ultima riga delllo stesso file non e' un delimitatore di run -> visualizza un opportuno messaggio
#                                                                          di errore e termina con fallimento
#      - altrimenti -> continua
#

# Se il file delle science windows da elaborare contiene almeno un delimitatore di run
if test $numberOfRunDelimiters -gt 0
then
   # Controlla che la prima riga (risp. l'ultima) del file delle science window da elaborare non
   # corrisponda (risp. corrisponda) al delimitatore di run, in caso contrario, segnala la
   # condizione d'errore e termina con fallimento
   checkScwsFileSyntax $listOfScwsAbsolutePath

   #  Memorizza in una variabile ausiliaria l'esito del controllo
   outcome=$?

   # Se l'esito del controllo non e' positivo restituisce un opportuno messaggio di errore
   # e termina con fallimento
   if test $outcome -ne $SUCCESS
   then
      echo -e "${ERROR_MESSAGES_ARRAY[$outcome]}"
      exit $FAILURE
   fi
fi

# Recupera il numero di core assegnati al container che effettua l'elaborazione
containerNumberOfCores=$(cat /proc/cpuinfo|grep processor|wc -l)

# Calcola il numero delle scw nel file di quelle da elaborare che le contiene 
countScwsToBeProcessed $listOfScwsAbsolutePath
scwsToBeProcessed=$?

#
# Debug
#
#   Verificare:
#
#   il corretto conteggio:
#      - dei core assegnati al container che effettua l'elaborazione
#      - delle scw nel file di quelle da elaborare che le contiene
#
# echo -e "\n######### Debug - Inizio ############################################\n"
# 
# echo "containerNumberOfCores: $containerNumberOfCores"
# echo "scwsToBeProcessed: $scwsToBeProcessed"
#
# echo -e "\n######### Debug - Fine ##############################################\n"
#
# exit        
#

#
# Debug
#
# Verificare
#
# il funzionamento dello script in presenza di errori:
#    - il numero delle run parallele e' minore di 1 -> visualizza un opportuno messaggio
#                                                      di errore e termina con fallimento
#    - il numero delle run parallele e' maggiore
#      del numero di core assegnati al container -> visualizza un opportuno messaggio
#                                                   di errore e termina con fallimento;
#    - il numero dei delimitatori di run è
#      maggiore del numero di core assegnati al container -> visualizza un opportuno messaggio
#                                                            di errore e termina con fallimento;
#    - il numero dei delimitatori di run all'interno del 
#      file delle scw da elaborare e' diverso da quello
#      delle run parallele -> errore; termina con fallimento -> visualizza un opportuno messaggio
#                                                               di errore e termina con fallimento;
#    - il numero delle scw da elaborare e' minore
#      di quello delle run parallele -> visualizza un opportuno messaggio
#                                       di errore e termina con fallimento; 
#    - altrimenti -> continua

# Controlla la corretta relazione tra il numero di esecuzioni parallele per la stessa
# elaborazione, il numero dei delimitatori di run all'interno del file delle science window
# e il numero di core assegnati al container
checkParallelRunsParameters $numberOfParallelRuns \
                            $numberOfRunDelimiters \
                            $containerNumberOfCores \
                            $scwsToBeProcessed
                            
#  Memorizza in una variabile ausiliaria l'esito del controllo
outcome=$?

# Se l'esito del controllo non e' positivo restituisce un opportuno messaggio di errore
# e termina con fallimento
if test $outcome -ne $SUCCESS
then
  echo -e "${ERROR_MESSAGES_ARRAY[$outcome]}"
  exit $FAILURE
fi

# Forma il path assoluto della working directory per l'elaborazione
workingDirectoryAbsolutePath="$PATH_OF_OSA_MAIN_DIRECTORY/$workingDirectory"

# Controlla se nella main directory esiste una cartella o un file con lo stesso nome
# della working directory, in caso di risposta affermativa segnala la condizione di
# errore e termina con fallimento, altrimenti la crea con al suo interno una subdirectory
# destinata a contenere i file di log per l'elaborazione
checkFsItemExistence $workingDirectoryAbsolutePath

if test $? -eq $SUCCESS
then
   echo -e "${ERROR_MESSAGES_ARRAY[ERR_WORKING_DIRECTORY]}$workingDirectoryAbsolutePath"
   exit $FAILURE
else
   mkdir $workingDirectoryAbsolutePath
   mkdir $workingDirectoryAbsolutePath/$LOGS_DIRECTORY_NAME
fi

#
# Debug
#
# Verificare
#
# il funzionamento dello script in presenza di errori:
#    - nella main directory esiste una cartella o un file
#      con lo stesso nome della working directory -> visualizza un opportuno messaggio
#                                                     di errore e termina con fallimento;
#    - altrimenti -> continua
#

# Acquisisce l'istante di inizio del logging relativo
# alla elaborazione
logStartingTime=$(date +"%Y%m%d%H%M%S")

# Forma il nome del file di log per la elaborazione nel formato
# $ibisAnalysisEnvSetUp.sh-executionLog-loggingStartingTime 
exeLogName="$(basename $0)-$EXECUTION_LOGS_SUBNAME-$logStartingTime"

# Forma il path assoluto del file di log per la elaborazione
exeLogAbsolutePath="$workingDirectoryAbsolutePath/$LOGS_DIRECTORY_NAME/$exeLogName"

# Inserisce l'intestazione comune ai file di log per l'elaborazione 			
appendToLog "$(dateTime) $(basename $0) - $MSG_INTO $EXECUTION_LOGS_HEADER \nParameters: \n \
             \t <listOfScwsAbsolutePath>: $listOfScwsAbsolutePath \n \
             \t <workingDirectory>: $workingDirectory \n \
             \t <numberOfParallelRuns>: $numberOfParallelRuns \n" \
            "$exeLogAbsolutePath"

#
# Debug
#
#
# Visualizzare il contenuto del file di log
#
# echo -e "\n######### Debug - Inizio ############################################\n"
#
# cat $exeLogAbsolutePath
#
# echo -e "\n######### Debug - Fine ##############################################\n"
#
# exit
#            

# Effettua un controllo di qualita' sui dati, altrimenti
# traccia l'evento e continua
checkForDataQuality  $listOfScwsAbsolutePath \
                     $workingDirectoryAbsolutePath \
                     $exeLogAbsolutePath \
                     $logStartingTime
						   
if test $? -ne $SUCCESS
then
   # Nel caso in cui non vada a buon fine, traccia l'evento, visualizza un opportuno
   # messaggio di errore e termina con fallimento
   appendToLog "$(dateTime) $(basename $0) - $CHECK_FOR_DATA_QUALITY_FAILS" \
               "$exeLogAbsolutePath"
			  
   echo -e ${ERROR_MESSAGES_ARRAY[ERR_DATA_QUALITY_CHECK]}
   
   # Traccia l'uscita dallo script
   appendToLog "$(dateTime) $(basename $0) - $MSG_OUT_OF" \
               "$exeLogAbsolutePath"
			   
   #
   # Debug
   #
   #
   # Visualizzare il contenuto del file di log
   #
   # echo -e "\n######### Debug - Inizio ############################################\n"
   #
   # cat $exeLogAbsolutePath
   #
   # echo -e "\n######### Debug - Fine ##############################################\n"
   #
   # exit
   #  
   exit $FAILURE
fi

#
# Debug
#
# Verificare
#
# il funzionamento dello script in presenza di errori:
#    - una scw non contiene il file compton_events.fits.gz -> visualizza un opportuno messaggio
#                                                             di errore e termina con fallimento
#    - una scw non contiene il file isgri_events.fits.gz -> visualizza un opportuno messaggio
#                                                           di errore e termina con fallimento
#    - una scw non contiene il file il file swg.fits -> visualizza un opportuno messaggio
#                                                       di errore e termina con fallimento
#    - una scw contiene un file non conforme allo standard fits -> visualizza un opportuno messaggio
#                                                                  di errore e termina con fallimento
#    - altrimenti -> continua
#

# Altrimenti traccia l'evento e continua
appendToLog "$(dateTime) $(basename $0) - $CHECK_FOR_DATA_QUALITY_SUCCEEDS" \
            "$exeLogAbsolutePath"
			   
#
# Debug
#
#
# Visualizzare il contenuto del file di log
#
# echo -e "\n######### Debug - Inizio ############################################\n"
#
# cat $exeLogAbsolutePath
#
# echo -e "\n######### Debug - Fine ##############################################\n"
#
# exit
#  

# Costruisce la struttura a cartelle per le run parallele
# all'interno della working directory

runsDirectoriesContruction $workingDirectoryAbsolutePath \
                           $numberOfParallelRuns \
						   $exeLogAbsolutePath

# Popola la struttura a cartelle per le run parallele
# all'interno della working directory
runsSetUp $listOfScwsAbsolutePath \
          $workingDirectoryAbsolutePath \
          $numberOfParallelRuns \
          $numberOfRunDelimiters \
		  $exeLogAbsolutePath

						   
#
# Debug
#
# Verificare
#
# la corretta costruzione della struttura in subdirectorie richiesta per
# le parallel run
#    Visualizzare il numero di parallel run e il contenuto della working
#    directory
#
# echo -e "\n######### Debug - Inizio ############################################\n"
#
# echo "numberOfParallelRuns: $numberOfParallelRuns"
# ls -R $workingDirectoryAbsolutePath
#
# echo -e "\n######### Debug - Fine ##############################################\n"
#
# exit
#

# Traccia l'uscita dallo script
appendToLog "$(dateTime) $(basename $0) - $MSG_OUT_OF" \
            "$exeLogAbsolutePath"
			
#
# Debug
#
#
# Visualizzare il contenuto del file di log
#
# echo -e "\n######### Debug - Inizio ############################################\n"
#
# cat $exeLogAbsolutePath
#
# echo -e "\n######### Debug - Fine ##############################################\n"
#
# exit
#
exit
