#include <stdio.h>

#ifndef KRAKEN_UTIL
#include "kraken-util.h"
#endif

int
main (int argc, char **argv)
{
  /*
   * Generates a KRAKEN input file
   */
  int arg_counter = 0;

  double freq, c0;
  double receiver_depth_start, receiver_depth_delta, receiver_depth_stop, bottom_depth, max_range;
  char *svp_file, *output_file;

  FILE *fp;
  SVP *s;

  /*
   * Process the command line arguments
   */
  if (argc == 1) {
    fprintf (stderr, "usage: %s freq svp-file c0 receiver-depth-start",
	     argv[0]);
    fprintf (stderr, " receiver-depth-delta receiver-depth-stop bottom-depth max-range output-file\n");
    return(-1);
  }

  /* Read in the frequency */

  if (++arg_counter < argc) {
    if (sscanf(argv[arg_counter], "%lf", &freq) != 1) {
      fprintf (stderr, "frequency must be a floating point number, not [%s]\n",
	       argv[arg_counter]);
      return(-1);
    }
  } else {
    fprintf (stderr, "need frequency to generate an input file\n");
    return(-1);
  }

  /* Read in the SVP file */

  if (++arg_counter < argc) 
    svp_file = argv[arg_counter];
  else {
    fprintf (stderr, "need SVP file to generate an input file\n");
    return(-1);
  }

  /* Read in the minimum phase speed */

  if (++arg_counter < argc) {
    if (sscanf(argv[arg_counter], "%lf", &c0) != 1) {
      fprintf (stderr, "c0 must be a floating point number, not [%s]\n",
	       argv[arg_counter]);
      return(-1);
    }
  } else {
    fprintf (stderr, "need c0 to generate an input file\n");
    return(-1);
  }

  /* Read in the receiver depth start */

  if (++arg_counter < argc) {
    if (sscanf(argv[arg_counter], "%lf", &receiver_depth_start) != 1) {
      fprintf (stderr, "min_receiver_depth must be a floating point number, not [%s]\n",
	       argv[arg_counter]);
      return(-1);
    }
  } else {
    fprintf (stderr, "need receiver depth start to generate an input file\n");
    return(-1);
  }

  /* Read in the receiver depth delta */

  if (++arg_counter < argc) {
    if (sscanf(argv[arg_counter], "%lf", &receiver_depth_delta) != 1) {
      fprintf (stderr, "c0 must be a floating point number, not [%s]\n",
	       argv[arg_counter]);
      return(-1);
    }
  } else {
    fprintf (stderr, "need receiver depth delta to generate an input file\n");
    return(-1);
  }

  /* Read in the receiver depth stop */

  if (++arg_counter < argc) {
    if (sscanf(argv[arg_counter], "%lf", &receiver_depth_stop) != 1) {
      fprintf (stderr, "receiver_depth_stop must be a floating point number, not [%s]\n",
	       argv[arg_counter]);
      return(-1);
    }
  } else {
    fprintf (stderr, "need receiver_depth_stop to generate an input file\n");
    return(-1);
  }

  /* Read in the bottom depth */

  if (++arg_counter < argc) {
    if (sscanf(argv[arg_counter], "%lf", &bottom_depth) != 1) {
      fprintf (stderr, "bottom_depth must be a floating point number, not [%s]\n",
	       argv[arg_counter]);
      return(-1);
    }
  } else {
    fprintf (stderr, "need bottom_depth to generate an input file\n");
    return(-1);
  }

  /* Read in the maximum range */

  if (++arg_counter < argc) {
    if (sscanf(argv[arg_counter], "%lf", &max_range) != 1) {
      fprintf (stderr, "max_range must be a floating point number, not [%s]\n",
	       argv[arg_counter]);
      return(-1);
    }
  } else {
    fprintf (stderr, "need max_range to generate an input file\n");
    return(-1);
  }

  /* Get the output file */

  if (++arg_counter < argc) 
    output_file = argv[arg_counter];
  else {
    fprintf (stderr, "need output file name to write\n");
    return(-1);
  }

  /*
   * End of command line argument processing
   */

  /* Read in the SVP */

  fp = fopen (svp_file, "r");
  if (fp == NULL) {
    perror ("fopen SVP");
    return(-1);
  }
  s = read_baseline_water_svp (fp);
  if (s == NULL) {
    fprintf (stderr, "error reading in baseline water SVP from [%s]\n",
	     svp_file);
    return(-1);
  }
  fclose(fp);

  /*
   * Open the output file (KRAKEN input file)
   */
  fp = fopen (output_file, "w");
  if (fp == NULL) {
    perror ("fopen SVP");
    return(-1);
  }

  /*
   * Write the KRAKEN input file
   */
  (void)write_kraken_setup (fp, s, freq, c0,
			    receiver_depth_start, receiver_depth_delta, receiver_depth_stop,
			    bottom_depth, max_range);
  
  /*
   * Close the KRAKEN input file
   */
  fclose(fp);

  /* All done */

  return(0);
}