/*----------------------------------------------------------------------------*/
/**
   @file    dfits.c
   @author  Nicolas Devillard
   @date    30 Mar 2000
   @version	$Revision: 1.3 $
   @brief   FITS header display
*/
/*----------------------------------------------------------------------------*/

/*
	$Id: dfits.c,v 1.3 2005/07/19 15:38:52 yjung Exp $
	$Author: yjung $
	$Date: 2005/07/19 15:38:52 $
	$Revision: 1.3 $
 */

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "qfits.h"

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

#define BLOCK_SIZE  2880
#define LGTH    	80
#define MAGIC   	"SIMPLE  ="

/* If compiled against zlib, include support for gzipped files */
#if HAVE_ZLIB
#include "zlib.h"
#define FILE            gzFile
#define fopen           gzopen
#define fclose          gzclose
#define fread(b,s,n,f)  gzread(f,b,n*s)
#endif

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

void usage(char * pname) ;
void parse_cmd_line(int, char **, int *, int *, int *) ;
int dump_fits_filter(FILE *, int) ;
int dump_fits(char *, int) ;
char * rstrip(char *) ;

/*-----------------------------------------------------------------------------
                                Main
 -----------------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
	int		xtnum ;
	int		c_arg ;
	int		filter ;
	int		err ;

	/* No arguments prints out a usage message */
	if (argc<2) usage(argv[0]);

	/* Parse command-line options */
	parse_cmd_line(argc, argv, &xtnum, &filter, &c_arg);

	/* Filter mode: process data received from stdin */
	if (filter) {
#if HAVE_ZLIB
        printf("filter mode does not support gzipped files\n");
        printf("use: gunzip -c file.fits | dfits -\n");
        return 1 ;
#else
		return dump_fits_filter(stdin, xtnum);
#endif
    }

	/* Normal mode: loop on all file names given on command-line */
	err = 0 ;
	while (c_arg < argc) {
		err += dump_fits(argv[c_arg], xtnum);
		c_arg++;
	}
	return err ; /* Returns number of errors during process */
}

void usage(char * pname)
{
	printf(
"\n\n"
"usage: %s [-x xtnum] <list of FITS files>\n"
"usage: %s [-x xtnum] -\n"
"\n"
"The former version expects file names.\n"
"The latter expects data coming in from stdin.\n"
"\n"
"-x xtnum specifies the extension header to print\n"
"-x 0     specifies main header + all extensions\n"
"\n\n",
	pname, pname);

#if HAVE_ZLIB
    printf(
"This program was compiled against zlib %s\n"
"This means you can use it with gzipped FITS files\n"
"as with uncompressed FITS files.\n"
"NB: this does not apply to the '-' option (input from stdin)\n"
"\n\n", ZLIB_VERSION);
#endif
    exit(1) ;
}

void parse_cmd_line(
        int         argc,
        char    **  argv,
        int     *	xtnum,
        int     *	filter,
        int     *	c_arg)
{
	*filter = 0 ;
	*xtnum  = -1 ;
	*c_arg  = argc-1 ;

	/* If '-' is on the command-line, it must be the last argument */
	if (!strcmp(argv[argc-1], "-")) *filter = 1 ;
	/* If -x xtnum is on the command-line, it must be the first two arguments */
	if (!strcmp(argv[1], "-x")) {
		*xtnum = atoi(argv[2]);
		*c_arg = 3 ;
	} else {
		*c_arg = 1 ;
	}
	return ;
}

/* Strip off all blank characters in a string from the right-side. */
char * rstrip(char * s)
{
    int len ;
    if (s==NULL) return s ;
    len = strlen(s);
    if (len<1) return s ;
    len -- ;
    while (s[len]== ' ') {
        s[len]=(char)0 ;
        len --;
        if (len<0) break ;
    }
    return s ;
}

/* Dump the requested header (main or extension) from a filename. */
int dump_fits(char * name, int xtnum)
{
	FILE	*	in ;
	int			err ;

	if ((in=fopen(name, "r"))==NULL) {
		fprintf(stderr, "error: cannot open file [%s]\n", name);
		return 1 ;
	}

	printf("====> file %s (main) <====\n", name) ;
	err = dump_fits_filter(in, xtnum);
	fclose(in);
	return err ;
}

/* Dump the requested header (main or extension) from a FILE * */
int dump_fits_filter(FILE * in, int xtnum)
{
	int		    n_xt ;
	char	    buf[LGTH+1];
	int		    err ;
    int         data_bytes, naxis ;
    char    *   read_val ;
    int         skip_blocks ;
    int         seeked ;

	/* Try getting the first 80 chars */
	memset(buf, 0, LGTH+1);
	if (fread(buf, sizeof(char), LGTH, in)!=LGTH) {
		fprintf(stderr, "error reading input\n");
		return 1;
	}
	/* Check that it is indeed FITS */
	if (strncmp(buf, MAGIC, strlen(MAGIC))) {
		fprintf(stderr, "not a FITS file\n");
		return 1 ;
	}
    naxis = 0 ;
    data_bytes = 1 ;
	if (xtnum<1) {
		/* Output main header */
		printf("%s\n", rstrip(buf));
        data_bytes = 1 ;
        naxis = 0 ;
		while ((err=fread(buf, sizeof(char), LGTH, in))==LGTH) {
			printf("%s\n", rstrip(buf));
            /* Look for BITPIX keyword */
            if (buf[0]=='B' &&
                buf[1]=='I' &&
                buf[2]=='T' &&
                buf[3]=='P' &&
                buf[4]=='I' &&
                buf[5]=='X' &&
                buf[6]==' ') {
                read_val = qfits_getvalue(buf);
                data_bytes *= (int)atoi(read_val) / 8 ;
                if (data_bytes<0) data_bytes *= -1 ;
            } else
            /* Look for NAXIS keyword */
            if (buf[0]=='N' &&
                buf[1]=='A' &&
                buf[2]=='X' &&
                buf[3]=='I' &&
                buf[4]=='S') {

                if (buf[5]==' ') {
                    /* NAXIS keyword */
                    read_val = qfits_getvalue(buf);
                    naxis = (int)atoi(read_val);
                } else {
                    /* NAXIS?? keyword (axis size) */
                    read_val = qfits_getvalue(buf);
                    data_bytes *= (int)atoi(read_val);
                }
            } else
            /* Look for END keyword */
            if (buf[0]=='E' &&
				buf[1]=='N' &&
				buf[2]=='D') {
				break ;
			}
		}
		if (err!=LGTH) return 1 ;
	}
	if (xtnum<0) return 0 ;

	n_xt=0 ;
	while (1) {
        /*
         * Skip the previous data section if pixels were declared
         */
        if (naxis>0) {
            /* Skip as many blocks as there are declared pixels */
            skip_blocks = data_bytes/BLOCK_SIZE ;
            if ((data_bytes % BLOCK_SIZE)!=0) skip_blocks ++ ;
            seeked = fseek(in, skip_blocks*BLOCK_SIZE, SEEK_CUR);
            if (seeked<0) return -1 ;
        }

		/* Look for next XTENSION keyword */
		while ((err=fread(buf, sizeof(char), LGTH, in))==LGTH) {
			if (buf[0]=='X' &&
				buf[1]=='T' &&
				buf[2]=='E' &&
				buf[3]=='N' &&
				buf[4]=='S' &&
				buf[5]=='I' &&
				buf[6]=='O' &&
				buf[7]=='N') break ;
		}
		if (err==0)	break ;
		if (err!=LGTH) return 1 ;

		n_xt++ ;
        
        if (xtnum==0 || xtnum==n_xt) {
			printf("===> xtension %d\n", n_xt) ;
			printf("%s\n", rstrip(buf));
		}

        data_bytes = 1 ;
        naxis = 0 ;
        while ((err=fread(buf, sizeof(char), LGTH, in))==LGTH) {
            if (xtnum==0 || xtnum==n_xt) printf("%s\n", rstrip(buf));

            /* Look for BITPIX keyword */
            if (buf[0]=='B' &&
                buf[1]=='I' &&
                buf[2]=='T' &&
                buf[3]=='P' &&
                buf[4]=='I' &&
                buf[5]=='X' &&
                buf[6]==' ') {
                read_val = qfits_getvalue(buf);
                data_bytes *= (int)atoi(read_val) / 8 ;
                if (data_bytes<0) data_bytes *= -1 ;
            } else
            /* Look for NAXIS keyword */
            if (buf[0]=='N' &&
                buf[1]=='A' &&
                buf[2]=='X' &&
                buf[3]=='I' &&
                buf[4]=='S') {

                if (buf[5]==' ') {
                    /* NAXIS keyword */
                    read_val = qfits_getvalue(buf);
                    naxis = (int)atoi(read_val);
                } else {
                    /* NAXIS?? keyword (axis size) */
                    read_val = qfits_getvalue(buf);
                    data_bytes *= (int)atoi(read_val);
                }
            } else 
            /* Look for END keyword */
            if (buf[0]=='E' &&
                buf[1]=='N' &&
                buf[2]=='D') break ;
        }
        if (n_xt==xtnum) break ;
	}
	return 0 ;
}