/* Copyright 1995, Columbia University, all rights reserved.
 * Permission is granted to utilize and disseminate this code or
 *  document without charge, provided that (1) this copyright notice is 
 *  not removed, and (2) all changes made by other than members of the 
 *  MacroModel Development Group at Columbia University are, if further 
 *  disseminated, (a) noted as such; for example, by means of source-code 
 *  comment lines, and (b) communicated back to the author for possible 
 *  inclusion in subsequent versions. */
/****************************************************************************
 * $RCSfile: cfmmio.c,v $
 * $Revision: 1.19 $
 * $Date: 1996/04/08 17:29:31 $
 ***************************************************************************/

/* cfmmio: read mmod files from input and copy them to output.
 * Usage: cfmmio [-cf] <infile> <outfile>
 * if the "-f" option is given, always write full CTs on output even if 
 *  compressed CTs are present in input.  This is the default, and
 *  will uncompress a compressed mmod file.
 * if "-c" is specified, then compressed CTs will be written to the output
 *  whenever they appear in the input.  This amounts to a copy of the
 *  input file.
 * cfmmio does not compress full CTs.
 * cfmmio has two purposes: to provide an example of how to use the mmio API,
 *  and to make sure that some simple facilities of the mmio library are
 *  working correctly. cfmmio always gives verbose output, which would not
 *  be desirable in a "real" application. */

#include "mmio.h"
#if defined( GETOPT_STDLIB )
	#include <stdlib.h>
#elif defined( GETOPT_UNISTD )
	#include <unistd.h>
#elif defined( GETOPT_GETOPT )
	#include <getopt.h>
#endif

#define err() \
 printf( "ERR encountered, file %s, line %d\n", __FILE__, __LINE__ )

static void usage( void );
/************************************************************************/
main( int narg, char *arg[] )
{
	int status;
	int ict, iatom, natom;
	char title[ MMIO_L_STRLEN + 1];
	char readfname[200], writefname[200];

	/* for malloc() cleanliness: */
	char stdout_buf[BUFSIZ + 8];

	int mmod_iatom;
	int itype;
	int nbond;
	int bond_atom[ MMIO_MAXBOND ];
	int bond_order[ MMIO_MAXBOND ];
	float xyz[ 3 ];
	float charge1;
	float charge2;
	char chain;
	int color;
	int resnum;
	char resname1;
	char resname4[ 5 ];
	char pdbname[ 5 ];
	int ct_type_requested = MMIO_FULL;
	int opt;
	extern int optind;
	int iread, iwrite;

	/* line buffer stdout, in case of problems: */
	setvbuf( stdout, stdout_buf, _IOLBF, BUFSIZ );

	/* parse cmdline options: */
	while( (opt=getopt(narg,arg,"cf")) != -1 ) {
		switch( opt ) {
			case 'c':
				ct_type_requested = MMIO_COMPRESSED;
				break;
			case 'f':
				ct_type_requested = MMIO_FULL;
				break;
			default:
				usage();
				return 1;
		}
	}

	/* make sure that two cmdline args remain after any options: */
	if( narg-optind != 2 ) {
		usage();
		return 1;
	}

	/* get input filename from first remaining cmdline arg: */
	strcpy( readfname, arg[optind++] );
	printf( "cfmmio main: readfname= '%s'\n", readfname );

	/* get output filename from second remaining cmdline arg: */
	strcpy( writefname, arg[optind++] );
	printf( "cfmmio main: writefname= '%s'\n", writefname );
	
	/* tell mmio library to write its errmsgs, if any, to stdout: */
	mmio_errfile( stdout );
	printf( "cfmmio main: mmio_errfile returns %s\n", "successfully" );

	/* open input file for reading; note use of mmio_return_code() to
	 *  give ASCII equivalent of the return status: */
	status = mmio_open( &iread, readfname, MMIO_READ );
	printf( "cfmmio main: mmio_open() returns %s for %s\n",
	 mmio_return_code(status), readfname );
	if( status == MMIO_ERR ) {
		err();
		return 1;
	}

	/* open output file for writing; */
	status = mmio_open( &iwrite, writefname, MMIO_WRITE );
	printf( "cfmmio main: mmio_open() returns %s for %s\n",
	 mmio_return_code(status), writefname );
	if( status == MMIO_ERR ) {
		err();
		return 1;
	}

	ict = 0;
	/* read structures, one by one, from input file & write to output: */
	while( 1 ) {

		/* request first CT: */
		status = mmio_get_ct( iread, ct_type_requested, &natom, title );
		printf( "cfmmio main: mmio_get_ct() returns %s for ict %d;"
		 " natom= %d\n", mmio_return_code(status), ict, natom );
		if( status == MMIO_ERR ) {
			err();
			return 1;
		}
		if( status == MMIO_EOF ) {
			/* no more structures to be read: */
			break;
		}
		printf( "cfmmio main:     natom=%d, title=\n'%s'\n",
		 natom, title );

		/* write out CT with whatever status mmio_get_ct()
		 *  returned; if ct_type_requested was MMIO_FULL,
		 *  status will be MMIO_FULL;  if ct_type_requested
		 *  was MMIO_COMPRESSED, status will be MMIO_COMPRESSED if
		 *  the input file contained a compressed CT, and MMIO_FULL
		 *  if the input file contained a full CT: */
		status = mmio_put_ct( iwrite, status, natom, title );
		printf( "cfmmio main: mmio_put_ct() returns %s; natom= %d\n",
		 mmio_return_code(status), natom );
		if( status == MMIO_ERR ) {
			err();
			return 1;
		}

		/* For each atom, get the atom info from the input file
		 *  and write it to the output file.
		 * Please note that the interleaving of gets and puts is
		 *  not a requirement of MMIO, but was just the most
		 *  convenient way to code this particular application: */
		for( iatom=0; iatom<natom; ++iatom ) {

			/* get: */
			status = mmio_get_atom( iread, &mmod_iatom, &itype,
			 &nbond, bond_atom, bond_order, xyz, &charge1, &charge2,
			 &chain, &color, &resnum, &resname1, resname4, 
			 pdbname );
			printf( "cfmmio main: mmio_get_atom() returns %s for "
			 "iatom, mmod_iatom= %d %d\n",
			 mmio_return_code(status), iatom, mmod_iatom );
			if( status == MMIO_ERR ) {
				err();
				return 1;
			}

			/* put: */
			status = mmio_put_atom( iwrite, mmod_iatom, itype,
			 nbond, bond_atom, bond_order, xyz, charge1, charge2, 
			 chain, color, resnum, resname1, resname4, 
			 pdbname );
			printf( "cfmmio main: mmio_put_atom() returns %s\n",
			 mmio_return_code(status) );
			if( status == MMIO_ERR ) {
				err();
				return 1;
			}
		}
		ict += 1;
	}

	/* print summary info: */
	printf( "cfmmio main: %d CT's found in input file\n", ict );


	/* following is just a double check; mmio_get_ct() should return 
	 *  MMIO_EOF again; this call isn't necessary, but is just there 
	 *  to see if mmio_get_ct() is doing the Right Thing: */
	printf( "cfmmio main: trying mmio_get_ct() again, just for fun:\n" );
	status = mmio_get_ct( iread, MMIO_FULL, &natom, title );
	printf( "cfmmio main: mmio_get_ct() returns %s for ict %d;"
	 " natom= %d\n",
	 mmio_return_code(status), ict, natom );

	#ifdef DBMALLOC
		/* just for fun, see how much storage was allocated by mmio: */
		printf( "cfmmio main: before closing iread, malloc()'ed"
		 " storage in use= %d bytes\n", malloc_inuse(NULL) );
	#endif

	/* close input file;  not really necessary under UNIX: */
	status = mmio_close( iread );

	/* close output file;  not really necessary under UNIX: */
	printf( "cfmmio main: mmio_close() returns %s for readfile\n",
	 mmio_return_code(status) );
	#ifdef DBMALLOC
		/* see how much storage is still allocated after input
		 *  file close: */
		printf( "cfmmio main: before closing iwrite, malloc()'ed"
		 " storage in use= %d bytes\n", malloc_inuse(NULL) );
	#endif

	status = mmio_close( iwrite );
	printf( "cfmmio main: mmio_close() returns %s for writefile\n",
	 mmio_return_code(status) );
	#ifdef DBMALLOC
		/* see how much storage is still allocated after output
		 *  file close: */
		printf( "cfmmio main: before mmio_cleanup, malloc()'ed"
		 " storage in use= %d bytes\n", malloc_inuse(NULL) );
	#endif

	/* free all remaining allocated mmio storage; not really necessary
	 *  under UNIX: */
	status = mmio_cleanup( );
	printf( "cfmmio main: mmio_cleanup() returns %s for writefile\n",
	 mmio_return_code(status) );
	#ifdef DBMALLOC
		/* we should have zero storage still allocated; do we? : */
		printf( "cfmmio main: after mmio_cleanup, malloc()'ed"
		 " storage in use= %d bytes\n", malloc_inuse(NULL) );
		if( malloc_inuse(NULL) != 0 ) {
			/* if there's any storage still in use, tell us
			 *  about it: */
			printf( "cfmmio main: just before end,"
			 " malloc_dump():\n" ); malloc_dump( 1 );
		}
	#endif

	/* announce our success to the world: */
	printf( "cfmmio main: SUCCESSFUL COMPLETION\n" );

	return 0;
}
/************************************************************************/
static void usage( void )
 /* print a line telling the user how the program is supposed to be called: */
{
	printf( "Usage: cfmmio [-cf] <infile> <outfile>\n" );
}
/************************************************************************/