/*---------------------------------------------------------------------------
   
   File name 	:	is_rename_engine.c
   Author 		:	Y. Jung
   Created on	:	January 2001
   Description	:	Renaming related functions

 *--------------------------------------------------------------------------*/

/*
	$Id: is_rename_engine.c,v 1.34 2002/02/11 08:00:53 yjung Exp $
	$Author: yjung $
	$Date: 2002/02/11 08:00:53 $
	$Revision: 1.34 $
*/

/*---------------------------------------------------------------------------
   								Includes
 ---------------------------------------------------------------------------*/

#include "is_rename_engine.h"
#include "isaacp_lib.h"
#include "irstd.h"
#include "calendar.h"

/* Statistics on files */
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

/*---------------------------------------------------------------------------
   								Define
 ---------------------------------------------------------------------------*/

#define	RENAME_LOW_RES			1000
#define	RENAME_MED_RES			1001

#define	RENAME_TECH_IMA			1002
#define RENAME_TECH_SPEC		1003

#define RENAME_TYPE_STD			1004
#define	RENAME_TYPE_OBS			1005

#define RENAME_CORRELATED		1006
#define RENAME_UNCORRELATED		1007

#define RENAME_A_ASCII_DECIMAL	65
#define RENAME_NB_OF_LETTERS	26

/*---------------------------------------------------------------------------
   							Function prototypes
 ---------------------------------------------------------------------------*/

static int rename_get_resolution(char * filename) ;
static int rename_get_dpr_tech(char * filename) ;
static int rename_get_dpr_type(char * filename) ;

static char * rename_get_dit(char * filename) ;
static char * rename_get_filter(char * filename) ;
static char * rename_get_central_wavelength(char * filename) ;
static char * rename_get_optical_id(char * filename) ;
static char * rename_get_obs_id(char * filename) ;
static char * rename_get_target(char * filename) ;
static int rename_dark_romode(char * filename) ;

static char * rename_compose_name(char *, char *, char *, char *) ;

/*---------------------------------------------------------------------------
  							Function codes
 ---------------------------------------------------------------------------*/

/*-------------------------------------------------------------------------*/
/**
  @name     isaac_compute_product_name  
  @memo     Find out the new file name by checking the header
  @param    filename    old file name
  @param	archive		Flag to use the archive name for renaming
  @param	origfile	Flag to use the origfile for renaming
  @param	ref_name	File used in option to compute a new_name (optional)
  @return   The new file name
  @doc
    The rules used to compute the new file name are implemented here.
 */
/*--------------------------------------------------------------------------*/
char * isaac_compute_product_name(
		char 	* 	filename, 
		int 		archive,
		int			origfile,
		char	*	ref_name)
{
	char		reffile[FILENAMESZ] ;
    char   	*   pro_catg ;
    char   	*   date ;
    char   		valid_date[6] ;
    char   		tmp_year[4] ;
    int    		hour,
                day,
            	month,
            	year ;
	int			res ;			
	int			dpr_tech ;
	int			dpr_type ;
	char	*	dit ;
	char	*	filter ;
	char	*	target ;
	char	*	obs_id ;
	char	*	optical_id ;
	char	*	wl ;
	char	*	lamp ;
    char        first[FILENAMESZ] ;
    char        second[FILENAMESZ] ;
	char		extension[5] ;
    char    *	final_name ;

	/* Which file is used to compute the new name */
	if (ref_name[0] == (char)0) {
		strcpy(reffile, filename) ;
	} else {
		strcpy(reffile, ref_name) ;
	}
	
	if ((!is_paf_file(reffile)) && (!is_fits_file(reffile))) {
		e_error("The reference file has to be FITS or PAF") ;
		return NULL ;
	}
	
	e_comment(0, "Find the new name of: %s", filename) ;

	/* Use Arcfile */
	if (archive) {
		final_name = isaac_get_arcfile(reffile) ;
		if (final_name == NULL) 
			e_error("cannot read ARCFILE from the header") ;
		else final_name = strdup(final_name) ;
		return final_name ;
	}

	/* Use Origfile */
	if (origfile) {
		final_name = isaac_get_origfile(reffile) ;
		free(reffile) ;
		if (final_name == NULL) 
			e_error("cannot read ORIGFILE from the header") ;
		else final_name = strdup(final_name) ;
		return final_name ;
	}
	
    /* Read the date */
    if ((date = isaac_get_date_obs(reffile)) == NULL) {
        e_error("cannot read DATE-OBS keyword in the header - abort") ;
        return NULL ;
    }
    if (sscanf(date, "%4d-%2d-%2dT%2d:%*s", &year, &month, &day, &hour) == 0) {
		e_error("cannot parse the DATE-OBS keyword - abort") ;
		return NULL ;
	}
	
    /* Test if the valid date is yesterday or today */
    if (hour < ISAAC_CHANGE_DAY_HOUR) calendar_getprev(&day, &month, &year) ;

    /* Get only 2 digits for the year: 2001 -> 01 */
    sprintf(tmp_year, "%04d", year) ;
    sscanf(tmp_year, "%*2d%2d", &year) ;

    /* Write down the valid date */
    sprintf(valid_date, "%02d%02d%02d", year, month, day) ;

    /* GET THE FIRST PART OF THE NEW NAME */
    
	/* Get the PRO CATG value of the product */
    if ((pro_catg = isaac_get_pro_catg(reffile)) == NULL) {
        e_error("cannot read PRO CATG keyword in the header - abort") ;
        return NULL ;
    }
    switch (isaac_get_pro_catg_key(pro_catg)) {
        case isaac_spec_sw_arc_coef:
		case isaac_spec_sw_arc_qc:
            res = rename_get_resolution(reffile) ;
			if (res == RENAME_LOW_RES) 
				sprintf(first, "IS_SSAL_%6s", valid_date) ;
            else if (res == RENAME_MED_RES) 
				sprintf(first, "IS_SSAM_%6s", valid_date) ;
            else {
                e_error("Resolution not recognized") ;
                return NULL ;
            }
            break ;
        case isaac_spec_lw_arc_coef:
        case isaac_spec_lw_arc_qc:
            res = rename_get_resolution(reffile) ;
			if (res == RENAME_LOW_RES) 
				sprintf(first, "IS_LSAL_%6s", valid_date) ;
            else if (res == RENAME_MED_RES) 
				sprintf(first, "IS_LSAM_%6s", valid_date) ;
            else {
                e_error("Resolution not recognized") ;
                return NULL ;
            }
            break ;
        case isaac_dark_result:
		case isaac_dark_ron:
			switch (isaac_get_wavelength_mode(reffile)) {
				case ISAAC_SW_MODE:
					dpr_tech = rename_get_dpr_tech(reffile) ;
					if (dpr_tech == RENAME_TECH_IMA) 
						sprintf(first, "IS_SIDK_%6s", valid_date) ;
					else if (dpr_tech == RENAME_TECH_SPEC) 
						sprintf(first, "IS_SSDK_%6s", valid_date) ;
					else {
						e_error("DPR TECH keyword not recognized") ;
						return NULL ;
					}
					break ;
				case ISAAC_LW_MODE:
					switch (rename_dark_romode(reffile)) {
						case RENAME_CORRELATED:
						sprintf(first, "IS_LGDD_%s", valid_date) ;
						break ;

						case RENAME_UNCORRELATED:
						sprintf(first, "IS_LGDU_%s", valid_date) ;
						break ;

						default:
						return NULL ;
						break ;
					}
					break ;
				default:
					e_error("cannot recognize the mode") ;
					return NULL ;
			}
			break ;
		case isaac_spec_sw_flat:
		case isaac_spec_sw_flat_qc:
			res = rename_get_resolution(reffile) ;
            if (res == RENAME_LOW_RES) 
				sprintf(first, "IS_SSFL_%6s", valid_date) ;
            else if (res == RENAME_MED_RES) 
				sprintf(first, "IS_SSFM_%6s", valid_date) ;
            else {
                e_error("Resolution not recognized") ;
                return NULL ;
            }
            break ;
        case isaac_spec_lw_flat:
		case isaac_spec_lw_flat_qc:
			res = rename_get_resolution(reffile) ;
            if (res == RENAME_LOW_RES) 
				sprintf(first, "IS_LSFL_%6s", valid_date) ;
            else if (res == RENAME_MED_RES) 
				sprintf(first, "IS_LSFM_%6s", valid_date) ;
            else {
                e_error("Resolution not recognized") ;
                return NULL ;
            }
            break ;
		case isaac_imag_illum:
            sprintf(first, "IS_SIIL_%6s", valid_date) ;
            break ;
        case isaac_imag_sw_jitter_result:
        case isaac_imag_sw_jitter_qc:
		case isaac_imag_sw_jitter_objs:
		case isaac_imag_sw_jitter_off:
            sprintf(first, "IS_SIJC_%6s", valid_date) ;
            break ;
        case isaac_spec_sw_resp_extr:
        case isaac_spec_sw_resp_back:
        case isaac_spec_sw_resp_conv:
        case isaac_spec_sw_resp_effi:
			res = rename_get_resolution(reffile) ;
            if (res == RENAME_LOW_RES) 
				sprintf(first, "IS_SSRL_%6s", valid_date) ;
            else if (res == RENAME_MED_RES) 
				sprintf(first, "IS_SSRM_%6s", valid_date) ;
            else {
                e_error("Resolution not recognized") ;
                return NULL ;
            }
            break ;
		case isaac_spec_lw_resp_extr:
        case isaac_spec_lw_resp_back:
        case isaac_spec_lw_resp_conv:
        case isaac_spec_lw_resp_effi:
			res = rename_get_resolution(reffile) ;
            if (res == RENAME_LOW_RES) 
				sprintf(first, "IS_LSRL_%6s", valid_date) ;
            else if (res == RENAME_MED_RES) 
				sprintf(first, "IS_LSRM_%6s", valid_date) ;
            else {
                e_error("Resolution not recognized") ;
                return NULL ;
            }
            break ;
        case isaac_spec_sw_jitter_comb:
        case isaac_spec_sw_jitter_extr:
        case isaac_spec_sw_jitter_qc:
            res = rename_get_resolution(reffile) ;
			dpr_type = rename_get_dpr_type(reffile) ;
			if (dpr_type == RENAME_TYPE_STD) {
                if (res == RENAME_LOW_RES) 
					sprintf(first, "IS_SSSL_%6s", valid_date) ;
                else if (res == RENAME_MED_RES) 
					sprintf(first, "IS_SSSM_%6s", valid_date) ;
                else {
                    e_error("Resolution not recognized") ;
                    return NULL ;
                }
            } else if (dpr_type == RENAME_TYPE_OBS) {
                if (res == RENAME_LOW_RES) 
					sprintf(first, "IS_SSCL_%6s", valid_date) ;
                else if (res == RENAME_MED_RES) 
					sprintf(first, "IS_SSCM_%6s", valid_date) ;
                else {
                    e_error("Resolution not recognized") ;
                    return NULL ;
                }
            } else {
                e_error("Observation type not recognized") ;
                return NULL ;
            }
            break ;
        case isaac_spec_lw_jitter_comb:
        case isaac_spec_lw_jitter_extr:
		case isaac_spec_lw_jitter_qc:
            res = rename_get_resolution(reffile) ;
			dpr_type = rename_get_dpr_type(reffile) ;
			if (dpr_type == RENAME_TYPE_STD) {
                if (res == RENAME_LOW_RES) 
					sprintf(first, "IS_LSSL_%6s", valid_date) ;
                else if (res == RENAME_MED_RES) 
					sprintf(first, "IS_LSSM_%6s", valid_date) ;
                else {
                    e_error("Resolution not recognized") ;
                    return NULL ;
                }
            } else if (dpr_type == RENAME_TYPE_OBS) {
                if (res == RENAME_LOW_RES) 
					sprintf(first, "IS_LSCL_%6s", valid_date) ;
                else if (res == RENAME_MED_RES) 
					sprintf(first, "IS_LSCM_%6s", valid_date) ;
                else {
                    e_error("Resolution not recognized") ;
                    return NULL ;
                }
            } else {
                e_error("Observation type not recognized") ;
                return NULL ;
            }
            break ;
		case isaac_imag_lw_jitter_result:
			sprintf(first, "IS_LIJC_%6s", valid_date) ;
			break ;
		case isaac_spec_sw_sttr_pos:
        case isaac_spec_sw_sttr_shape:
        case isaac_spec_sw_sttr_corresp:
        case isaac_spec_sw_sttr_disto:
        case isaac_spec_sw_sttr_extract:
		case isaac_spec_sw_sttr_qc:
            sprintf(first, "IS_SSST_%6s", valid_date) ;
            break ;
        case isaac_spec_lw_sttr_pos:
        case isaac_spec_lw_sttr_shape:
        case isaac_spec_lw_sttr_corresp:
        case isaac_spec_lw_sttr_disto:
        case isaac_spec_lw_sttr_extract:
		case isaac_spec_lw_sttr_qc:
            sprintf(first, "IS_LSST_%6s", valid_date) ;
			break ;
		case isaac_imag_sw_flat_result:
        case isaac_imag_sw_flat_badpix:
        case isaac_imag_sw_flat_interce:
        case isaac_imag_sw_flat_errmap:
            sprintf(first, "IS_SITF_%6s", valid_date) ;
            break ;
		case isaac_imag_zpoint_result:
		case isaac_imag_zpoint_qc:
			sprintf(first, "IS_GIZP_%6s", valid_date) ;
			break ;
		case isaac_spec_combine:
		case isaac_imag_bg:
		case isaac_spec_sw_arc_corr:
        case isaac_spec_lw_arc_corr:
        case isaac_spec_extract:
        case isaac_imag_sw_jitter_diff:
        case isaac_spec_slitpos_table:
		case isaac_spec_slitpos_qc:
        case isaac_spec_sw_jitter_aver:
        case isaac_spec_sw_jitter_diff:
        case isaac_spec_lw_jitter_aver:
        case isaac_spec_lw_jitter_diff:
        case isaac_spec_sw_sttr_correct:
        case isaac_spec_lw_sttr_correct:
        	e_comment(1, "File registered but not supported") ;
			return NULL ;
			break ;
		default:
            e_error("PRO CATG key not recognized") ;
            return NULL ;
            break ;
    }

    /* GET THE SECOND PART OF THE NEW NAME */

	/* Get the PRO CATG value of the product */
    if ((pro_catg = isaac_get_pro_catg(reffile)) == NULL) {
        e_error("cannot read PRO CATG keyword in the header - abort") ;
        return NULL ;
    }
    switch (isaac_get_pro_catg_key(pro_catg)) {
        case isaac_spec_sw_arc_coef:
        case isaac_spec_lw_arc_coef:
		case isaac_spec_sw_arc_qc:
        case isaac_spec_lw_arc_qc:
			if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
            if ((optical_id = rename_get_optical_id(reffile)) == NULL) {
                free(filter) ;
                return NULL ;
            }
            if ((wl = rename_get_central_wavelength(reffile)) == NULL) {
                free(filter) ;
                free(optical_id) ;
                return NULL ;
            }
			if ((lamp = isaac_get_pro_catalog(reffile)) == NULL) {
				free(filter) ;
				free(optical_id) ;
				free(wl) ;
				return NULL ;
			}
            sprintf(second, "_%s_%s_%s_%s", filter, optical_id, wl, lamp) ;
			free(filter) ;
            free(optical_id) ;
            free(wl) ;
			break ;
        case isaac_dark_result:
			if ((dit = rename_get_dit(reffile)) == NULL) return NULL ;
            sprintf(second, "_DIT=%s", dit) ;
			free(dit) ;
            break ;
        case isaac_dark_ron:
			sprintf(second, "_RON") ;
			break ;
        case isaac_spec_sw_flat:
        case isaac_spec_lw_flat:
		case isaac_spec_sw_flat_qc:
		case isaac_spec_lw_flat_qc:
			if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			if ((optical_id = rename_get_optical_id(reffile)) == NULL) {
				free(filter) ;
				return NULL ;
			}
			if ((wl = rename_get_central_wavelength(reffile)) == NULL) {
				free(filter) ;
				free(optical_id) ;
				return NULL ;
			}
			sprintf(second, "_%s_%s_%s", filter, optical_id, wl) ;
			free(filter) ;
			free(optical_id) ;
			free(wl) ;
            break ;
        case isaac_imag_illum:
            if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			sprintf(second, "_%s", filter) ;
			free(filter) ;
            break ;
        case isaac_imag_sw_jitter_result:
        case isaac_imag_lw_jitter_result:
			if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			if ((obs_id = rename_get_obs_id(reffile)) == NULL) {
				free(filter) ;
				return NULL ;
			}
            sprintf(second, "_%s_%s", filter, obs_id) ;
			free(filter) ;
			free(obs_id) ;
            break ;
		case isaac_imag_sw_jitter_off:
			if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			if ((obs_id = rename_get_obs_id(reffile)) == NULL) {
				free(filter) ;
				return NULL ;
			}
            sprintf(second, "_%s_%s_offsets", filter, obs_id) ;
			free(filter) ;
			free(obs_id) ;
			break ;
		case isaac_imag_sw_jitter_objs:
			if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			if ((obs_id = rename_get_obs_id(reffile)) == NULL) {
				free(filter) ;
				return NULL ;
			}
            sprintf(second, "_%s_%s_objects", filter, obs_id) ;
			free(filter) ;
			free(obs_id) ;
			break ;
        case isaac_imag_sw_jitter_qc:
        	if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			if ((obs_id = rename_get_obs_id(reffile)) == NULL) {
				free(filter) ;
				return NULL ;
			}
            sprintf(second, "_%s_%s_qc", filter, obs_id) ;
			free(filter) ;
			free(obs_id) ;
			break ;
		case isaac_spec_sw_resp_extr:
		case isaac_spec_lw_resp_extr:
            if ((target = rename_get_target(reffile)) == NULL) return NULL ;
			if ((filter = rename_get_filter(reffile)) == NULL) {
				free(target) ;
				return NULL ;
			}
			if ((optical_id = rename_get_optical_id(reffile)) == NULL) {
				free(target) ;
				free(filter) ;
				return NULL ;
			}
			if ((wl = rename_get_central_wavelength(reffile)) == NULL) {
				free(target) ;
				free(filter) ;
				free(optical_id) ;
				return NULL ;
			}
			sprintf(second, "_%s_%s_%s_%s_extr", target,filter,optical_id,wl);
			free(target) ;
			free(filter) ;
			free(optical_id) ;
			free(wl) ;
			break ;
        case isaac_spec_sw_resp_back:
        case isaac_spec_lw_resp_back:
            if ((target = rename_get_target(reffile)) == NULL) return NULL ;
            if ((filter = rename_get_filter(reffile)) == NULL) {
				free(target) ;
				return NULL ;
			}
			if ((optical_id = rename_get_optical_id(reffile)) == NULL) {
				free(target) ;
				free(filter) ;
				return NULL ;
			}
			if ((wl = rename_get_central_wavelength(reffile)) == NULL) {
				free(target) ;
				free(filter) ;
				free(optical_id) ;
				return NULL ;
			}
			sprintf(second, "_%s_%s_%s_%s_back",target,filter,optical_id,wl);
			free(target) ;
			free(filter) ;
			free(optical_id) ;
			free(wl) ;
            break ;
        case isaac_spec_sw_resp_conv:
        case isaac_spec_lw_resp_conv:
            if ((target = rename_get_target(reffile)) == NULL) return NULL ;
            if ((filter = rename_get_filter(reffile)) == NULL) {
				free(target) ;
				return NULL ;
			}
			if ((optical_id = rename_get_optical_id(reffile)) == NULL) {
				free(target) ;
				free(filter) ;
				return NULL ;
			}
			if ((wl = rename_get_central_wavelength(reffile)) == NULL) {
				free(target) ;
				free(filter) ;
				free(optical_id) ;
				return NULL ;
			}
			sprintf(second, "_%s_%s_%s_%s_conversion", target, filter, 
					optical_id, wl) ;
			free(target) ;
			free(filter) ;
			free(optical_id) ;
			free(wl) ;
            break ;
        case isaac_spec_sw_resp_effi:
        case isaac_spec_lw_resp_effi:
            if ((target = rename_get_target(reffile)) == NULL) return NULL ;
            if ((filter = rename_get_filter(reffile)) == NULL) {
				free(target) ;
				return NULL ;
			}
			if ((optical_id = rename_get_optical_id(reffile)) == NULL) {
				free(target) ;
				free(filter) ;
				return NULL ;
			}
			if ((wl = rename_get_central_wavelength(reffile)) == NULL) {
				free(target) ;
				free(filter) ;
				free(optical_id) ;
				return NULL ;
			}
			sprintf(second, "_%s_%s_%s_%s_efficiency", target, filter, 
					optical_id, wl) ;
			free(target) ;
			free(filter) ;
			free(optical_id) ;
			free(wl) ;
            break ;
        case isaac_spec_sw_jitter_comb:
        case isaac_spec_sw_jitter_extr:
        case isaac_spec_sw_jitter_qc:
        case isaac_spec_lw_jitter_comb:
        case isaac_spec_lw_jitter_extr:
		case isaac_spec_lw_jitter_qc:
            dpr_type = rename_get_dpr_type (reffile) ;
			if (dpr_type == RENAME_TYPE_STD) {
				if ((target = rename_get_target(reffile))==NULL) return NULL ;
				sprintf(second, "_%s", target) ;
				free(target) ;
			} else second[0] = (char)0 ;   
			if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			if ((optical_id = rename_get_optical_id(reffile)) == NULL) {
				free(filter) ;
				return NULL ;
			}
			if ((wl = rename_get_central_wavelength(reffile)) == NULL) {
				free(filter) ;
				free(optical_id) ;
				return NULL ;
			}
			if ((obs_id = rename_get_obs_id(reffile)) == NULL) {
				free(filter) ;
				free(optical_id) ;
				free(wl) ;
				return NULL ;
			}
			sprintf(second, "%s_%s_%s_%s_%s", second, filter, optical_id, wl,
					obs_id) ;
			free(filter) ;
			free(optical_id) ;
			free(wl) ;
			free(obs_id) ;
            break ;
        case isaac_spec_sw_sttr_pos:
        case isaac_spec_lw_sttr_pos:
            sprintf(second, "_positions") ;
            break ;
		case isaac_spec_sw_sttr_qc:
		case isaac_spec_lw_sttr_qc:
			sprintf(second, "_qc") ;
			break ;
		case isaac_spec_sw_sttr_shape:
        case isaac_spec_lw_sttr_shape:
            sprintf(second, "_shapes") ;
            break ;
        case isaac_spec_sw_sttr_disto:
        case isaac_spec_lw_sttr_disto:
			res = rename_get_resolution(reffile) ;
			if (res == RENAME_LOW_RES) sprintf(second, "_poly2d_LR") ;
            else if (res == RENAME_MED_RES) sprintf(second, "_poly2d_MR") ;
            else {
                e_error("Resolution not recognized") ;
                return NULL ;
            }
            break ;
        case isaac_spec_sw_sttr_corresp:
        case isaac_spec_lw_sttr_corresp:
            sprintf(second, "_corresp") ;
            break ;
        case isaac_spec_sw_sttr_extract:
        case isaac_spec_lw_sttr_extract:
            sprintf(second, "_extracted") ;
            break ;
        case isaac_imag_sw_flat_result:
			if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			sprintf(second, "_%s", filter) ;
			free(filter) ;
			break ;
        case isaac_imag_sw_flat_badpix:
			if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			sprintf(second, "_%s_badpix", filter) ;
			free(filter) ;
            break ;
        case isaac_imag_sw_flat_interce:
			if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			sprintf(second, "_%s_intercept", filter) ;
			free(filter) ;
            break ;
        case isaac_imag_sw_flat_errmap:
			if ((filter = rename_get_filter(reffile)) == NULL) return NULL ;
			sprintf(second, "_%s_errmap", filter) ;
			free(filter) ;
            break ;
		case isaac_imag_zpoint_result:
			if ((target = rename_get_target(reffile)) == NULL) return NULL ;
			if ((filter = rename_get_filter(reffile)) == NULL) {
				free(target) ;
				return NULL ;
			}
			sprintf(second, "_%02d_%s_%s_check", hour, target, filter) ;
			free(target) ;
			free(filter) ;
			break ;
		case isaac_imag_zpoint_qc:
			if ((target = rename_get_target(reffile)) == NULL) return NULL ;
			if ((filter = rename_get_filter(reffile)) == NULL) {
				free(target) ;
				return NULL ;
			}
			sprintf(second, "_%02d_%s_%s", hour, target, filter) ;
			free(target) ;
			free(filter) ;
			break ;
		case isaac_spec_combine:
		case isaac_imag_bg:
		case isaac_spec_sw_arc_corr:
        case isaac_spec_lw_arc_corr:
        case isaac_spec_extract:
        case isaac_imag_sw_jitter_diff:
        case isaac_spec_slitpos_table:
		case isaac_spec_slitpos_qc:
        case isaac_spec_sw_jitter_aver:
        case isaac_spec_sw_jitter_diff:
        case isaac_spec_lw_jitter_aver:
        case isaac_spec_lw_jitter_diff:
        case isaac_spec_sw_sttr_correct:
        case isaac_spec_lw_sttr_correct:
        	e_comment(1, "File registered but not supported") ;
			return NULL ;
			break ;
        default:
            e_error("PRO CATG key not recognized") ;
            return NULL ;
            break ;
    }

    /* GET THE EXTENSION OF THE NEW NAME */
	if (ref_name[0] != (char)0) {
		sprintf(extension, get_extname(filename)) ;
	} else {
		if (is_paf_file(filename)) sprintf(extension, "paf") ;
		else if (qfits_is_table(filename, 1)) sprintf(extension, "tfits") ;
		else if (is_fits_file(filename)) sprintf(extension, "fits") ;
		else {
			e_error("File type not recognized - abort") ;
			return NULL ;
		}
	}

	/* Use first and second to compose the final file name	 */
	final_name = rename_compose_name(filename, first, second, extension) ;

    return final_name ;
}


/*-------------------------------------------------------------------------*/
/**
  @name		rename_get_resolution
  @memo		Get the resolution from a FITS header	
  @param	filename	FITS file name
  @return	int RENAME_LOW_RES or RENAME_MED_RES, -1 in error case		
 */
/*--------------------------------------------------------------------------*/
static int rename_get_resolution(char * filename) 
{
	char	*	static_char ;
	char		reso[32] ;

	if ((static_char = isaac_get_resolution(filename)) == NULL) {
		e_error("cannot get resolution") ;
		return -1 ;
	}
	
	strcpy(reso, strlwc(static_char)) ;
	if (reso[0] == 'l') return RENAME_LOW_RES ; 
	else if (reso[0] == 'm') return RENAME_MED_RES ;
	else return -1 ;
}

/*-------------------------------------------------------------------------*/
/**
  @name		rename_get_dpr_tech
  @memo		Get the observation technic from a FITS header	
  @param	filename	FITS file name
  @return	int RENAME_TECH_IMA or RENAME_TECH_SPEC, -1 in error case		
 */
/*--------------------------------------------------------------------------*/
static int rename_get_dpr_tech(char * filename) 
{
	char	*	static_char ;
	char		tech[32] ;

	if ((static_char = isaac_get_dpr_tech(filename)) == NULL) {
		e_error("cannot get dpr tech") ;
		return -1 ;
	}
	strcpy(tech, static_char) ;
	if (!strcmp(tech, "IMAGE")) return RENAME_TECH_IMA ; 
	else if (!strcmp(tech, "SPECTRUM")) return RENAME_TECH_SPEC ;
	else return -1 ;
}

/*-------------------------------------------------------------------------*/
/**
  @name		rename_get_dpr_type
  @memo		Get the observation type from a FITS header	
  @param	filename	FITS file name
  @return	int RENAME_TYPE_STD or RENAME_TYPE_OBS, -1 in error case		
 */
/*--------------------------------------------------------------------------*/
static int rename_get_dpr_type(char * filename) 
{
	char	*	static_char ;
	char		type[32] ;

	if ((static_char = isaac_get_dpr_type(filename)) == NULL) {
		e_error("cannot get dpr type") ;
		return -1 ;
	}
	strcpy(type, static_char) ;
	if (!strcmp(type, "STD")) return RENAME_TYPE_STD ; 
	else if (!strcmp(type, "OBJECT")) return RENAME_TYPE_OBS ;
	else return -1 ;
}


/*-------------------------------------------------------------------------*/
/**
  @name		rename_get_dit
  @memo		Get the DIT from a FITS header
  @param	filename	FITS file name
  @return	allocated string (to be freed...)
 */
/*--------------------------------------------------------------------------*/
static char * rename_get_dit(char * filename)
{
	char	*	static_char ;
	char	*	dit ;
	int			int_chars ;
	int			dec_chars ;		
	int			tot_chars ;		
	
	int			i ;

	/* Initialize */
	i = 0 ;
	int_chars = dec_chars = 0 ;

	if ((static_char = isaac_get_dit(filename)) == NULL) {
		e_error("cannot get DIT") ;
		return NULL ;
	}
	dit = strdup(static_char) ;

	/* Truncate the 0s at the end */
	while (dit[i] != '\0') {
		if (dit[i] == '.') {
			dit[i] = '_' ;
			i++ ;
			while (dit[i] != '\0') {
				if (dit[i] != '0') dec_chars = i - int_chars ;
				i++ ;
			}
			break ;
		} else int_chars ++ ;
		i++ ;
	}

	if (dec_chars == 0) tot_chars = int_chars ;
	else tot_chars = int_chars + dec_chars + 1 ;
	dit[tot_chars] = '\0' ;
	
	return dit ;
}

/*-------------------------------------------------------------------------*/
/**
  @name		rename_get_filter
  @memo		Get the filter from a FITS header
  @param	filename	FITS file name
  @return	allocated string (to be freed...)
 */
/*--------------------------------------------------------------------------*/
static char * rename_get_filter(char * filename)
{
	char	*	static_char ;
	char	*	filter ;

	int			i = 0 ;
	if ((static_char = isaac_get_filter(filename)) == NULL) {
		e_error("cannot get filter") ;
		return NULL ;
	}
	filter = strdup(static_char) ;
	while (filter[i] != '\0') {
		if (filter[i] == '.') filter[i] = '_' ;
		i++ ;
	}
	return filter ;

}


/*-------------------------------------------------------------------------*/
/**
  @name		rename_get_central_wavelength
  @memo		Get the central wavelength from a FITS header
  @param	filename	FITS file name
  @return	allocated string (to be freed...)
 */
/*--------------------------------------------------------------------------*/
static char * rename_get_central_wavelength(char * filename)
{
	double		wl_double ;
	char	*	wl_char ;

	if ((wl_double = isaac_get_central_wavelength(filename)) == -1) {
		e_error("cannot get central wavelength") ;
		return NULL ;
	}
	wl_char = malloc(32 * sizeof(char)) ;
	if (wl_double < 10000) {
		sprintf(wl_char, "0%3f", wl_double) ;
		/* Keek only the 3 first digits  */
		wl_char[3] = '\0' ;
	} else {
		sprintf(wl_char, "%7.1f", wl_double) ;
		/* Keek only the 3 first digits  */
		wl_char[3] = '\0' ;
	}
	
	return wl_char ;
}


/*-------------------------------------------------------------------------*/
/**
  @name		rename_get_optical_id
  @memo		Get the optical ID from a FITS header
  @param	filename	FITS file name
  @return	allocated string (to be freed...)
 */
/*--------------------------------------------------------------------------*/
static char * rename_get_optical_id(char * filename)
{
	char	*	static_char ;
	char	*	opti ;
	int			i = 0 ;
	
	if ((static_char = isaac_get_optical_id(filename)) == NULL) {
		e_error("cannot get observation ID") ;
		return NULL ;
	}
	opti = strdup(static_char) ;

	if (!strcmp(opti, "slit_0.3_tilted")) {
		sprintf(opti, "s03t") ;
		return opti ;
	} else if (!strcmp(opti, "slit_1")) {
		 sprintf(opti, "sl1") ;
		 return opti ;
	} else if (!strcmp(opti, "slit_0.6_tilted")) {
		sprintf(opti, "s06t") ;
		return opti ;
	} else if (!strcmp(opti, "slit_2")) {
		sprintf(opti, "sl2") ;
		return opti ;
	}

	while (opti[i] != '\0') {
		if (opti[i] == '.') opti[i] = '_' ;
		i++ ;
	}
	return opti ;
}


/*-------------------------------------------------------------------------*/
/**
  @name		rename_get_target
  @memo		Get the OBS TARG NAME from a FITS header
  @param	filename	FITS file name
  @return	allocated string (to be freed...)
 */
/*--------------------------------------------------------------------------*/
static char * rename_get_target(char * filename)
{
	char	*	static_char ;
	char	*	star1 ;
	char	*	star2 ;
	int			name_pos ;
	int			i, j ;	

	if ((static_char = isaac_get_obs_targ_name(filename)) == NULL) {
		e_error("cannot get target") ;
		return NULL ;
	}
	
	/* Find position of the name: abc/def/ghi => ghi is the right name */
	name_pos = strlen(static_char) - 1 ;
	while ((name_pos >= 0) && (static_char[name_pos] != '/')) name_pos -- ;
	/* Get the good name */
	star1 = strdup(static_char+name_pos+1) ;
	i = 0 ;
	while ((star1[i] != '/') && (star1[i] != '\0')) i++ ;
	star1[i] = '\0' ;
	
	/* Get rid of '-' in the name	 */
	star2 = strdup(star1) ;
	j=0 ;
	for (i=0 ; i<strlen(star1) ; i++) {
		if (star1[i] != '-') {
			star2[j] = star1[i] ;
			j++ ;
		}
	}
	free(star1) ;	
	star2[j] = '\0' ;
	return star2 ;
}


/*-------------------------------------------------------------------------*/
/**
  @name		rename_get_obs_id
  @memo		Get the observation ID from a FITS header
  @param	filename	FITS file name
  @return	allocated string (to be freed...)
 */
/*--------------------------------------------------------------------------*/
static char * rename_get_obs_id(char * filename)
{
	char	*	static_char ;

	if ((static_char = isaac_get_obs_id(filename)) == NULL) {
		e_error("cannot get observation ID") ;
		return NULL ;
	}
	return strdup(static_char) ;
}


/*-------------------------------------------------------------------------*/
/**
  @name		rename_dark_romode
  @memo		Get the observation ID from a FITS header
  @param	filename	FITS file name
  @return	allocated string (to be freed...)
 */
/*--------------------------------------------------------------------------*/
static int rename_dark_romode(char * filename)
{
	char * s ;

	if ((s=isaac_get_romode_name(filename)) == NULL) {
		e_error("cannot get readout mode name") ;
		return -1 ;
	}
	if (!strcmp(s, "UncorrHighBias"))     return RENAME_UNCORRELATED ;
	if (!strcmp(s, "UncorrHighBiasCal"))  return RENAME_UNCORRELATED ;
	if (!strcmp(s, "DoubleCorrHighBias")) return RENAME_CORRELATED ;
	if (!strcmp(s, "DoubleCorrLowBias"))  return RENAME_CORRELATED ;
	if (!strcmp(s, "DoubleCorrLowBiasCal"))  return RENAME_CORRELATED ;
	if (!strcmp(s, "DoubleCorrHighBiasCal")) return RENAME_CORRELATED ;

	return -1 ;
}


/*-------------------------------------------------------------------------*/
/**
  @name		rename_compose_name
  @memo		Compose the final output name	
  @param	filename	Old file name
  @param	first	First part of the final name
  @param	second	Second part of the final name
  @param	extension extension of the file
  @return	allocated string (to be freed...)
  @doc
  	If the file firstAsecond exists, try firstBsecond, firstCsecond ...
 */
/*--------------------------------------------------------------------------*/
static char * rename_compose_name(
		char	*	filename,
		char	*	first,
		char	*	second,
		char	*	extension)
{
	int				letter ;
	char		*	outname ;
	char			tmp_name[FILENAMESZ] ;
	char			dir_name[FILENAMESZ] ;
	struct	stat	f1 ;
	struct	stat	f2 ;

	/* Initialize */
	letter = RENAME_A_ASCII_DECIMAL ;
	
	sprintf(dir_name, get_dirname(filename)) ;
	
	if (!strcmp(dir_name, ".")) {
		sprintf(tmp_name, "%s%c%s.%s", first, (char)letter, second, extension) ;
	} else {	
		sprintf(tmp_name, "%s/%s%c%s.%s", dir_name, first, (char)letter, 
				second, extension) ;
	}

	while ((file_exists(tmp_name) == 1) 
			&& (letter < RENAME_A_ASCII_DECIMAL + RENAME_NB_OF_LETTERS)) {
		/* Old file name = New file name */
		stat(tmp_name, &f1);
		stat(filename, &f2);
		if (f1.st_ino == f2.st_ino) {
			e_comment(1, "The file name is already correct") ;
			return NULL ;
		}
		letter++ ;
		e_comment(1, "%s already exists", tmp_name) ;
		if (!strcmp(dir_name, ".")) {
			sprintf(tmp_name, "%s%c%s.%s", first, (char)letter, second, 
					extension) ;
		} else {	
			sprintf(tmp_name, "%s/%s%c%s.%s", dir_name, first, (char)letter, 
					second, extension) ;
		}
	}
	if (letter == RENAME_A_ASCII_DECIMAL + RENAME_NB_OF_LETTERS) return NULL ;
	outname = strdup(tmp_name) ;
	return outname ;
}