/*
   Name- AddMirsToNprovs.c

   Language- C     Type- MAIN

   Version- 1.0    Date-  2/28/2026   Programmer- Mike Pettey (STC)

   Function- This program extracts data from MIRS granules and collocates
             the data to selected collocations times and locations.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <archive_entry.h>
#include <archive.h>
#include <netcdf.h>
#include <netcdf_mem.h>

#include "uthash.h"
#include "mirs_collocator.h"

//#define  MAX_TIME_DIFF       6.0
#define  MAX_TIME_DIFF     6.0 * 60.0 * 60.0
#define  MAX_DISTANCE_DIFF 200.0

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#define  DEG_TO_RAD    (M_PI / 180.0)


//#define  TRUE      0
//#define  FALSE     1


int createCollocationArray(int date_to_process);
int addSondeLevelDataToCollocationArray(int in_id, int date_to_process);
int createOutputFile(int date_to_process, int nprovs_platform_id, char *nprovs_platform_name, int in_id);
int copyAttributes(int in_id, int out_id);
void defineDimensionsAndVariables(int nc_id, int num_collocations);
void copyPreviousPlatforms(int in_id, int out_id, int platform_id);
void copyNetCDFGroup(int in_id, int out_id, int group_id, int date_group_id);
void doCollocations(int out_id, int date_to_process, char *tarball_name);
void findMatchingGranules(char *tarball_name);
int copyMirsDataToOutputFile(struct collocation_data *collocations, int num_collocations,
			     struct FileEntry *hash_table, char *tarball_name, int out_id);

float calculateTimeDifference(int date1, int time1, int date2, int time2);
float calculateDistanceDifference(float lat1, float lon1, float lat2, float lon2);

long convertDateAndTimeToEpochTime(int date, int time);
void convertEpochTimeToDateAndTime(double epoch_time, int *yr, int *md, int *hr, int *ms);

void unpackGranuleDateAndTime(char *time_string, int* date, int* time);

int fileStartsWith(char *file_name, char *token);
int fileEndsWith(char *file_name, char *token);

void addFileToHash(const char *name);


struct collocation_data *collocations;
struct FileEntry *collocated_files_hash = NULL;
int num_collocations;
int out_date_group_id, mirs_id;



int main(int argc, char *argv[])
  {
  int  date_to_process, nprovs_platform_id, out_id;
  int  in_id, max_sonde_levels, coll;
  int  attributes_copied;
  int  num_collocations_copied, actual_collocations;
  char nprovs_platform_name[100];
  //  struct FileEntry *collocated_files_hash = NULL;

  // Print an initial message

  printf("\nCollocating MIRS data with NPROVS\n\n");

  // Unpack the date to process

  date_to_process = atoi(argv[1]);

  // Unpack the platform ID and platform name

  nprovs_platform_id = atoi(argv[2]);
  sprintf(nprovs_platform_name, "%s", argv[3]);

  printf("Date to process:  %d\n\n", date_to_process);
  printf("NPROVS Platform ID:    %d\n", nprovs_platform_id);
  printf("NPROVS Platform Name:  %s\n\n", nprovs_platform_name);

  // Create the collocation array that will contain information about each
  // collocation

  in_id = createCollocationArray(date_to_process);

  // Add the sonde drift level data to the collocation array

//  max_sonde_levels = addSondeLevelDataToCollocationArray(in_id, date_to_process);

  // Create and initialize the output netCDF file

  out_id = createOutputFile(date_to_process, nprovs_platform_id, nprovs_platform_name, in_id);

  // Set the closest collocation values to their initial default values

  for (coll=0; coll<num_collocations; coll++)
    {
    sprintf(collocations[coll].closest_snd_granule, "");
    sprintf(collocations[coll].closest_img_granule, "");
    sprintf(collocations[coll].closest_snow_granule, "");
    collocations[coll].closest_footprint = -32768;
    collocations[coll].closest_value = 99999999.9;

    sprintf(collocations[coll].snd_name, "");
    sprintf(collocations[coll].img_name, "");
    sprintf(collocations[coll].snow_name, "");
    }

  
  // Loop through all of the MIRS granules to collocate the closest footprint to
  // each collocation

  printf("Collocating footprints\n");

  doCollocations(mirs_id, date_to_process, "mirs.file1");
  doCollocations(mirs_id, date_to_process, "mirs.file2");
  doCollocations(mirs_id, date_to_process, "mirs.file3");

  // Find matching IMG and Snow granules

  printf("Finding matching IMG and SFR granules\n");

  findMatchingGranules("mirs.file1");
  findMatchingGranules("mirs.file2");
  findMatchingGranules("mirs.file3");


  // Loop through the collocations and add the collocated file names to
  // the collocated file hash

  for (coll=0; coll<num_collocations; coll++)
    {
    if (collocations[coll].closest_footprint != -32768)
      {
      if (strlen(collocations[coll].closest_snd_granule) > 0)
	addFileToHash(collocations[coll].closest_snd_granule);

      if (strlen(collocations[coll].closest_img_granule) > 0)
	addFileToHash(collocations[coll].closest_img_granule);

      if (strlen(collocations[coll].closest_snow_granule) > 0)
	addFileToHash(collocations[coll].closest_snow_granule);
      }
    }


  //printf("\n");
  actual_collocations = 0;
  for (coll=0; coll<num_collocations; coll++)
    {
//printf("Coll:   %d    %d\n", coll, collocations[coll].closest_footprint);
    if (collocations[coll].closest_footprint != -32768)
      {
      actual_collocations++;
//    printf("\nCollocation:  %d   %d\n", coll, collocations[coll].closest_footprint);
//    printf("    SND:   %s\n", collocations[coll].closest_snd_granule);
//    printf("    IMG:   %s\n", collocations[coll].closest_img_granule);
//    printf("    Snow:  %s\n", collocations[coll].closest_snow_granule);
      }
    }

  // Define the dimensions and variables

  defineDimensionsAndVariables(mirs_id, num_collocations);

  // Copy the data to the output file

  num_collocations_copied =  copyMirsDataToOutputFile(collocations, num_collocations,
						      collocated_files_hash, "mirs.file1", mirs_id);
  num_collocations_copied += copyMirsDataToOutputFile(collocations, num_collocations,
						      collocated_files_hash, "mirs.file2", mirs_id);
  num_collocations_copied += copyMirsDataToOutputFile(collocations, num_collocations,
						      collocated_files_hash, "mirs.file3", mirs_id);

  printf("\n\nNumber of collocations:  %d\n\n", actual_collocations);
  
  // Copy all of the previous platform data to the output file

  copyPreviousPlatforms(in_id, out_id, nprovs_platform_id);

  // Close the input NPROVS collocation file

  nc_close(in_id);

  // Close the output file

  nc_close(out_id);

  printf("\nProcessing completed.\n\n");
  }



//-------------------------------------------------------------------------------
int createCollocationArray(int date_to_process)
  {
  int    retval, in_id, num_groups, date_group_id, var_id, dim_id, group_ids[100];
  int    n, coll, level;
  char   group_name[NC_MAX_NAME];
  int    *collocation_dates, *collocation_times;
  float  *collocation_lats, *collocation_lons;
  size_t dimlen;
  size_t index[1], num_vals[1];

  // Open the input NPROVS collocation file

  retval = nc_open("in.file", NC_NOWRITE, &in_id);

  if (retval != NC_NOERR)
    {
    printf("\n\n*** ERROR ***\n\n");
    printf("The NPROVS collocation netCDF file could not be read.\n");
    printf("netCDF Error Code:  %d\n", retval);
    printf("Execution is stopping.\n\n");
    exit(1);
    }

  // Get the subgroups

  retval = nc_inq_grps(in_id, &num_groups, group_ids);
  date_group_id = group_ids[0];

  // Get the subgroups of the first subgroup

  retval = nc_inq_grps(date_group_id, &num_groups, group_ids);

  // Find the Collocation_Info group

  for (n=0; n<num_groups; n++)
    {
    retval = nc_inq_grpname(group_ids[n], group_name);

    if (strcmp(group_name, "Collocation_Info") == 0)
      {

      // Unpack the number of collocations

      retval = nc_inq_dimid(group_ids[n], "Num_Collocations", &dim_id);
      retval = nc_inq_dimlen(group_ids[n], dim_id, &dimlen);

      num_collocations = (int)dimlen;

      printf("Number of collocations:  %d\n", num_collocations);

      index[0]    = 0;
      num_vals[0] = (size_t)num_collocations;

      // Unpack the collocation dates

      collocation_dates = (int*)malloc(num_collocations*(sizeof(int)));

      retval = nc_inq_varid(group_ids[n], "date", &var_id);
      retval = nc_get_vara_int(group_ids[n], var_id, index, num_vals, collocation_dates);

      // Unpack the collocation times

      collocation_times = (int*)malloc(num_collocations*(sizeof(int)));

      retval = nc_inq_varid(group_ids[n], "time", &var_id);
      retval = nc_get_vara_int(group_ids[n], var_id, index, num_vals, collocation_times);

      // Unpack the collocation latitudes

      collocation_lats = (float*)malloc(num_collocations*(sizeof(float)));

      retval = nc_inq_varid(group_ids[n], "latitude", &var_id);
      retval = nc_get_vara_float(group_ids[n], var_id, index, num_vals, collocation_lats);

      // Unpack the collocation longitudes

      collocation_lons = (float*)malloc(num_collocations*(sizeof(float)));

      retval = nc_inq_varid(group_ids[n], "longitude", &var_id);
      retval = nc_get_vara_float(group_ids[n], var_id, index, num_vals, collocation_lons);

      // Create the collocation array and copy the data into it

      collocations = (struct collocation_data*)malloc(num_collocations*sizeof(struct collocation_data));

      for (coll=0; coll<num_collocations; coll++)
        {
        collocations[coll].date        = collocation_dates[coll];
        collocations[coll].time        = collocation_times[coll];
        collocations[coll].latitude    = collocation_lats[coll];
        collocations[coll].longitude   = collocation_lons[coll];
        collocations[coll].cartesian_x = cos(collocation_lats[coll]*DEG_TO_RAD) * cos(collocation_lons[coll]*DEG_TO_RAD);
	collocations[coll].cartesian_y = cos(collocation_lats[coll]*DEG_TO_RAD) * sin(collocation_lons[coll]*DEG_TO_RAD);
        collocations[coll].cartesian_z = sin(collocation_lats[coll]*DEG_TO_RAD);
	
        //collocations[coll].epoch_time = convertDateAndTimeToEpochTime(collocation_dates[coll],
        //                                                              collocation_times[coll]) * (long)1000;
        collocations[coll].epoch_time = convertDateAndTimeToEpochTime(collocation_dates[coll],
                                                                      collocation_times[coll]);
        collocations[coll].closest_value = 99999999.9;

        // Initialize the sonde level collocation arrays

//        for (level=0; level<118; level++)
//          {
//          collocations[coll].sonde_drift_lat[level]  = -32768.0;
//          collocations[coll].sonde_drift_lon[level]  = -32768.0;
//          collocations[coll].sonde_epoch_time[level] = -32768.0;
//
//          collocations[coll].closest_sonde_value[level] = 99999999.9;
//          collocations[coll].closest_sonde_footprint[level] = -32768;
//
//          for (int i=0; i<500; i++)
//            collocations[coll].closest_sonde_granule[(level*500)+i] = '\0';
//          }
        }  // for (coll=0...

      // Free the collocation data memory

      free(collocation_lons);
      free(collocation_lats);
      free(collocation_times);
      free(collocation_dates);
      }  // if (strcmp(group_name...
    }  // for (n=0...

  return in_id;
  }



//-------------------------------------------------------------------------------
int addSondeLevelDataToCollocationArray(int in_id, int date_to_process)
  {
  int     retval, dim_id, var_id, date_group_id, sonde_group_id;
  int     num_platforms, plat_num, num_collocations, num_levels;
  int     coll, level, index;
  int     *platform_types, *dates, *times;
  long    coll_epoch_time;
  float   *pressures, *balloon_drift_lats, *balloon_drift_lons, *balloon_drift_time_deltas;
  char    date_group_name[500], sonde_group_name[500];
  char**  platform_dir_names;
  size_t  dim_length;

  // Unpack the directory name of the sonde

  retval = nc_inq_dimid(in_id, "Num_Platforms", &dim_id);
  retval = nc_inq_dimlen(in_id, dim_id, &dim_length);

  num_platforms = (int)dim_length;

  printf("Num Platforms:  %d\n", num_platforms);

  platform_types = (int*)malloc(num_platforms*sizeof(int));

  retval = nc_inq_varid(in_id, "platform_type", &var_id);
  retval = nc_get_var_int(in_id, var_id, platform_types);

  platform_dir_names = (char**)malloc(num_platforms*sizeof(char**));

  retval = nc_inq_varid(in_id, "platform_dir_name", &var_id);
  retval = nc_get_var_string(in_id, var_id, platform_dir_names);

  for (plat_num=0; plat_num<num_platforms; plat_num++)
    {
    if (platform_types[plat_num] == 0)
      sprintf(sonde_group_name, "%s", platform_dir_names[plat_num]);
    }

  // Open the sonde directory

  sprintf(date_group_name, "%d", date_to_process);
  retval = nc_inq_grp_ncid(in_id, date_group_name, &date_group_id);
  retval = nc_inq_grp_ncid(date_group_id, sonde_group_name, &sonde_group_id);

  // Unpack the number of collocations and number of levels

  retval = nc_inq_dimid(sonde_group_id, "Num_Collocations", &dim_id);
  retval = nc_inq_dimlen(sonde_group_id, dim_id, &dim_length);
  num_collocations = (int)dim_length;

  retval = nc_inq_dimid(sonde_group_id, "Levels", &dim_id);
  retval = nc_inq_dimlen(sonde_group_id, dim_id, &dim_length);
  num_levels = (int)dim_length;

  // Allocate memory for the level data in the collocation structure

  for (coll=0; coll<num_collocations; coll++)
    {
    collocations[coll].sonde_drift_lat  = (float*)malloc(num_levels*sizeof(float));
    collocations[coll].sonde_drift_lon  = (float*)malloc(num_levels*sizeof(float));
    collocations[coll].sonde_epoch_time = (long*)malloc(num_levels*sizeof(long));

    collocations[coll].closest_sonde_value     = (float*)malloc(num_levels*sizeof(float));
    collocations[coll].closest_sonde_footprint = (int*)malloc(num_levels*sizeof(int));
    collocations[coll].closest_sonde_granule   = (char*)malloc(num_levels*500*sizeof(char));
    }

  // Read the dates, times, pressures and balloon drift data

//  dates                     = (int*)malloc(num_collocations*sizeof(int));
//  times                     = (int*)malloc(num_collocations*sizeof(int));
//  pressures                 = (float*)malloc(num_collocations*num_levels*sizeof(float));
//  balloon_drift_lats        = (float*)malloc(num_collocations*num_levels*sizeof(float));
//  balloon_drift_lons        = (float*)malloc(num_collocations*num_levels*sizeof(float));
//  balloon_drift_time_deltas = (float*)malloc(num_collocations*num_levels*sizeof(float));

//  retval = nc_inq_varid(sonde_group_id, "date", &var_id);
//  retval = nc_get_var_int(sonde_group_id, var_id, dates);

//  retval = nc_inq_varid(sonde_group_id, "time", &var_id);
//  retval = nc_get_var_int(sonde_group_id, var_id, times);

//  retval = nc_inq_varid(sonde_group_id, "pressure", &var_id);
//  retval = nc_get_var_float(sonde_group_id, var_id, pressures);

//  retval = nc_inq_varid(sonde_group_id, "balloon_drift_latitude", &var_id);
//  retval = nc_get_var_float(sonde_group_id, var_id, balloon_drift_lats);

//  retval = nc_inq_varid(sonde_group_id, "balloon_drift_longitude", &var_id);
//  retval = nc_get_var_float(sonde_group_id, var_id, balloon_drift_lons);

//  retval = nc_inq_varid(sonde_group_id, "balloon_drift_time_delta", &var_id);
//  retval = nc_get_var_float(sonde_group_id, var_id, balloon_drift_time_deltas);

  // Loop through the collocations

//  for (coll=0; coll<num_collocations; coll++)
//    {
//    //coll_epoch_time = convertDateAndTimeToEpochTime(dates[coll], times[coll]) * (long)1000;
//    coll_epoch_time = convertDateAndTimeToEpochTime(dates[coll], times[coll]);

//    for (level=0; level<num_levels; level++)
//      {
//      index = (coll * num_levels) + level;

//      collocations[coll].sonde_drift_lat[level]  = balloon_drift_lats[index];
//      collocations[coll].sonde_drift_lon[level]  = balloon_drift_lons[index];

//      if (balloon_drift_time_deltas[index] != -32768.0)
//        collocations[coll].sonde_epoch_time[level] = coll_epoch_time + (3600.0 * balloon_drift_time_deltas[index]);
//      //else
//      //  collocations[coll].sonde_epoch_time[level] = coll_epoch_time;
//      }  // for (level=0...
//    }  // for (coll=0...

  // Free the allocated memory

//  free(times);
//  free(dates);
//  free(balloon_drift_time_deltas);
//  free(balloon_drift_lons);
//  free(balloon_drift_lats);
//  free(pressures);

  free(platform_dir_names);
  free(platform_types);

  return num_levels;
  }



//-------------------------------------------------------------------------------
void doCollocations(int out_id, int date_to_process, char *tarball_name)
  {
  int     i, coll, level, dir_index, fov, scan, fp_index;
  int     attributes_copied;
  int     num_scanlines, num_fovs, num_footprints, fp;
  int     retval, nc_id, dim_id, var_id;
  int     granule_start_date, granule_start_time;
  int     granule_end_date, granule_end_time;
  int     yyyy, mmdd, hh, mmss, yyyymmdd, hhmmss;
  int     *footprint_qcs, fill_value_qc;
  short   *scanline_year, *scanline_month, *scanline_day;
  short   *scanline_hour, *scanline_minute, *scanline_second;
  long    date_range_start, date_range_end;
  long    granule_start_epoch_time, granule_end_epoch_time;
  long    scanline_start_time, footprint_time;
  float   time_diff, dist_diff, closeness, time_factor;
  float   fill_value_lat, fill_value_lon;
  float   *footprint_lats, *footprint_lons;
  float   *footprint_x, *footprint_y, *footprint_z;
  double  fill_value_time;
  double  *footprint_times;
  char    file_name[500], time_string[25];
  size_t  dim_length;

  struct archive *a;
  struct archive_entry *entry;
  int r;

  float dist_diff_sq;
  float angle           = MAX_DISTANCE_DIFF / (2.0 * 6371.0088);
  float sin_angle       = sin(angle);
  float max_distance_sq = 4.0 * sin_angle * sin_angle;

  attributes_copied = FALSE;

  printf("doCollocations tarball name: %s\n", tarball_name);


  // Get the epoch times for the start and end of the date range

  date_range_start = convertDateAndTimeToEpochTime(date_to_process, 0) - (long)MAX_TIME_DIFF;
  date_range_end   = convertDateAndTimeToEpochTime(date_to_process, 235959) + (long)MAX_TIME_DIFF + (long)3600;

  // Loop through the tarball to find the closest SND footprints

  a = archive_read_new();
  archive_read_support_filter_gzip(a);
  archive_read_support_format_tar(a);
  
  r = archive_read_open_filename(a, tarball_name, 10240);

  if (r != ARCHIVE_OK)
    {
    printf("Error opening tarball for Pass 1: %s\n", tarball_name);
    archive_read_free(a);
    //exit(1);
    return;
    }

  while (archive_read_next_header(a, &entry) == ARCHIVE_OK)
    {
    const char *internal_filename = archive_entry_pathname(entry);
    size_t file_size = archive_entry_size(entry);

    sprintf(file_name, "%s", internal_filename);

    // Look ONLY at SND files on this first pass

    if ((fileStartsWith(file_name, "NPR-MIRS-SND") == TRUE) &&
	(fileEndsWith(file_name, ".nc") == TRUE))
      {
      void *nc_buffer = malloc(file_size);
      if (nc_buffer == NULL) continue;
      
      archive_read_data(a, nc_buffer, file_size);

      // Open NetCDF straight out of the RAM stream buffer

      retval = nc_open_mem(internal_filename, NC_NOWRITE, file_size, nc_buffer, &nc_id);
      //size_t initial_size = file_size;
      //retval = nc__open(internal_filename, NC_NOWRITE | NC_DISKLESS, 
      //                  &initial_size, (void *)&nc_buffer, &nc_id);

      if (retval == NC_NOERR)
        {
        retval = nc_get_att_text(nc_id, NC_GLOBAL, "time_coverage_start", time_string);
        unpackGranuleDateAndTime(time_string, &granule_start_date, &granule_start_time);
        granule_start_epoch_time = convertDateAndTimeToEpochTime(granule_start_date, granule_start_time);

        retval = nc_get_att_text(nc_id, NC_GLOBAL, "time_coverage_end", time_string);
        unpackGranuleDateAndTime(time_string, &granule_end_date, &granule_end_time);
        granule_end_epoch_time = convertDateAndTimeToEpochTime(granule_end_date, granule_end_time);

        if (((granule_start_epoch_time >= date_range_start) && (granule_start_epoch_time <= date_range_end)) ||
            ((granule_end_epoch_time >= date_range_start) && (granule_end_epoch_time <= date_range_end)))
          {

          // Read the number of scan lines and field of views for this granule

          retval = nc_inq_dimid(nc_id, "Scanline", &dim_id);
          retval = nc_inq_dimlen(nc_id, dim_id, &dim_length);
          num_scanlines = (int)dim_length;

          retval = nc_inq_dimid(nc_id, "Field_of_view", &dim_id);
          retval = nc_inq_dimlen(nc_id, dim_id, &dim_length);
          num_fovs = (int)dim_length;

          num_footprints = num_scanlines * num_fovs;

          // Read the scanline date and time from the granule and use them to calculate
          // the epoch time for each footprint

          footprint_times = (double*)malloc(num_footprints*sizeof(double));

          scanline_year   = (short*)malloc(num_scanlines*sizeof(short));
          scanline_month  = (short*)malloc(num_scanlines*sizeof(short));
          scanline_day    = (short*)malloc(num_scanlines*sizeof(short));
          scanline_hour   = (short*)malloc(num_scanlines*sizeof(short));
          scanline_minute = (short*)malloc(num_scanlines*sizeof(short));
          scanline_second = (short*)malloc(num_scanlines*sizeof(short));

          retval = nc_inq_varid(nc_id, "ScanTime_year", &var_id);
          retval = nc_get_var_short(nc_id, var_id, scanline_year);

          retval = nc_inq_varid(nc_id, "ScanTime_month", &var_id);
          retval = nc_get_var_short(nc_id, var_id, scanline_month);

          retval = nc_inq_varid(nc_id, "ScanTime_dom", &var_id);
          retval = nc_get_var_short(nc_id, var_id, scanline_day);

          retval = nc_inq_varid(nc_id, "ScanTime_hour", &var_id);
          retval = nc_get_var_short(nc_id, var_id, scanline_hour);

          retval = nc_inq_varid(nc_id, "ScanTime_minute", &var_id);
          retval = nc_get_var_short(nc_id, var_id, scanline_minute);

          retval = nc_inq_varid(nc_id, "ScanTime_second", &var_id);
          retval = nc_get_var_short(nc_id, var_id, scanline_second);

          fp_index = -1;

          for (scan=0; scan<num_scanlines; scan++)
            {
            yyyymmdd = (scanline_year[scan]*10000) + (scanline_month[scan]*100) + scanline_day[scan];
            hhmmss   = (scanline_hour[scan]*10000) + (scanline_minute[scan]*100) + scanline_second[scan];

            scanline_start_time = convertDateAndTimeToEpochTime(yyyymmdd, hhmmss);

            for (fov=0; fov<num_fovs; fov++)
              {
              fp_index++;
              footprint_times[fp_index] = scanline_start_time + (int)(fov * 0.02746212);
              }  // for (fov=0...
            }  // for (scan=0...

          free(scanline_second);
          free(scanline_minute);
          free(scanline_hour);
          free(scanline_day);
          free(scanline_month);
          free(scanline_year);

          // Read the footprint latitudes, longitudes and quality flags

          footprint_lats = (float*)malloc(num_footprints*sizeof(float));
          footprint_lons = (float*)malloc(num_footprints*sizeof(float));
          footprint_x    = (float*)malloc(num_footprints*sizeof(float));
          footprint_y    = (float*)malloc(num_footprints*sizeof(float));
          footprint_z    = (float*)malloc(num_footprints*sizeof(float));

          retval = nc_inq_varid(nc_id, "Latitude", &var_id);
          retval = nc_get_var_float(nc_id, var_id, footprint_lats);
          retval = nc_get_att_float(nc_id, var_id, "_FillValue", &fill_value_lat);

          retval = nc_inq_varid(nc_id, "Longitude", &var_id);
          retval = nc_get_var_float(nc_id, var_id, footprint_lons);
          retval = nc_get_att_float(nc_id, var_id, "_FillValue", &fill_value_lon);

          footprint_qcs = (int*)malloc(num_footprints*4*sizeof(int));

          retval = nc_inq_varid(nc_id, "Qc", &var_id);
          retval = nc_get_var_int(nc_id, var_id, footprint_qcs);
          retval = nc_get_att_int(nc_id, var_id, "_FillValue", &fill_value_qc);

          for (i=0; i<num_footprints; i++)
	    {
	    footprint_x[i] = cos(footprint_lats[i]*DEG_TO_RAD) * cos(footprint_lons[i]*DEG_TO_RAD);
	    footprint_y[i] = cos(footprint_lats[i]*DEG_TO_RAD) * sin(footprint_lons[i]*DEG_TO_RAD);
	    footprint_z[i] = sin(footprint_lats[i]*DEG_TO_RAD);
	    }
	  
          // Loop through each collocation

          for (coll=0; coll<num_collocations; coll++)
            {

            // Loop through each footprint

            for (fp=0; fp<num_footprints; fp++)
              {
              if (footprint_times[fp] != fill_value_time)
                {
                if (collocations[coll].epoch_time != -32768.0)
                  time_diff = fabs(footprint_times[fp] - collocations[coll].epoch_time);
                else
                  time_diff = -32768.0;

                // If the time difference is within the max limit, then check the distance

                if ((time_diff != -32768.0) && (time_diff <= MAX_TIME_DIFF))
                  {
//                  dist_diff = calculateDistanceDifference(footprint_lats[fp], footprint_lons[fp],
//                                                          collocations[coll].latitude,
//                                                          collocations[coll].longitude);
		  float dx = collocations[coll].cartesian_x - footprint_x[fp];
		  float dy = collocations[coll].cartesian_y - footprint_y[fp];
		  float dz = collocations[coll].cartesian_z - footprint_z[fp];

		  dist_diff_sq = (dx*dx) + (dy*dy) + (dz*dz);

//                  if (dist_diff <= MAX_DISTANCE_DIFF)
		  if (dist_diff_sq <= max_distance_sq)
                    {
                    time_factor = 30.0;
                    //closeness = dist_diff + (time_diff * time_factor);

		    dist_diff = 2.0 * 6371.0088 * asin(0.5 * sqrt(dist_diff_sq));

                    closeness = dist_diff + ((time_diff / 3600.0) * time_factor);

                    if (closeness < collocations[coll].closest_value)
                      {
//printf("   New champion found:   %f    %f  %f      %f  %f\n", dist_diff, collocations[coll].latitude, collocations[coll].longitude, footprint_lats[fp], footprint_lons[fp]);
		      collocations[coll].closest_value = closeness;
                      collocations[coll].closest_footprint = fp;
		      collocations[coll].closest_scanline  = fp / num_fovs;
		      collocations[coll].closest_fov       = fp % num_fovs;
                      sprintf(collocations[coll].closest_snd_granule, "%s", internal_filename);

		      // Save the new champion's SND file name

		      strcpy(collocations[coll].snd_name, internal_filename);

		      // If the attributes have not yet been copied to the output
		      // file, then copy them from the current granule

		      if (attributes_copied == FALSE)
			{  
			attributes_copied = copyAttributes(nc_id, mirs_id);
			}  // if (attributes_copied...
		      }  // if (closeness < collocations...
                    }  // if (dist_diff <= MAX_DISTANCE_DIFF...
                  }  // if (time_diff <= MAX_TIME_DIFF...
                }  // if (footprint_time != fill_value...
              }  // for (fp=0...
            }  // for (coll=0...

          free(footprint_qcs);
	  free(footprint_z);
	  free(footprint_y);
	  free(footprint_x);
          free(footprint_lons);
          free(footprint_lats);
          free(footprint_times);	  
          }  // if (granule_start_epoch_time...

        nc_close(nc_id);
        }  // if (retval==NC_NOERR...

      free(nc_buffer);
      }  // if (fileStartsWith SND...
    }  // while Pass 1...

  archive_read_free(a);
  }



//-------------------------------------------------------------------------------
void findMatchingGranules(char *tarball_name)
  {
  int     coll;
  char    file_name[500], substring[100];
  size_t  index;

  struct archive *a;
  struct archive_entry *entry;
  int r;

  a = archive_read_new();
  archive_read_support_filter_gzip(a);
  archive_read_support_format_tar(a);
  
  r = archive_read_open_filename(a, tarball_name, 10240);

  if (r != ARCHIVE_OK)
    {
    printf("Error opening tarball for Pass 2: %s\n", tarball_name);
    archive_read_free(a);
    //exit(1);
    return;
    }

  while (archive_read_next_header(a, &entry) == ARCHIVE_OK)
    {
    const char *internal_filename = archive_entry_pathname(entry);
    size_t file_size = archive_entry_size(entry);

    sprintf(file_name, "%s", internal_filename);

    // Look ONLY at IMG files
    if ((fileStartsWith(file_name, "NPR-MIRS-IMG") == TRUE) &&
	(fileEndsWith(file_name, ".nc") == TRUE))
      {

      // Process the collocations that had a MIRS footprint collocated

      for (coll=0; coll<num_collocations; coll++)
        {
        if (collocations[coll].closest_footprint != -32768)
          {

          // Pull out the substring for the starting and ending times

          char *pos = strstr(collocations[coll].closest_snd_granule, "_s");

          if (pos != NULL)
            {
            index = pos - collocations[coll].closest_snd_granule;

            strncpy(substring, (collocations[coll].closest_snd_granule + index), 34);
            substring[34] = '\0';

            pos = strstr(file_name, substring);

            if (pos != NULL)
              {
              sprintf(collocations[coll].closest_img_granule, "%s", file_name);
	      }  // if (pos != NULL...
            }  //if (pos != NULL...
          }  // if (collocations[coll].closest_footprint...
        }  // for (coll=0...
      }  // if ((fileStartsWith(IMG)...


    // Look ONLY at SFR files
    if ((fileStartsWith(file_name, "SFR_") == TRUE) &&
	(fileEndsWith(file_name, ".nc") == TRUE))
      {

      // Process the collocations that had a MIRS footprint collocated

      for (coll=0; coll<num_collocations; coll++)
        {
        if (collocations[coll].closest_footprint != -32768)
          {

          // Pull out the substring for the starting and ending times

          char *pos = strstr(collocations[coll].closest_snd_granule, "_s");

          if (pos != NULL)
            {
            index = pos - collocations[coll].closest_snd_granule;

            strncpy(substring, (collocations[coll].closest_snd_granule + index), 34);
            substring[34] = '\0';

            pos = strstr(file_name, substring);

            if (pos != NULL)
              {
              sprintf(collocations[coll].closest_snow_granule, "%s", file_name);
	      }  // if (pos != NULL...
            }  //if (pos != NULL...
          }  // if (collocations[coll].closest_footprint...
        }  // for (coll=0...
      }  // if ((fileStartsWith(SFR)...
    }  // while (archive_read_next_header...

  archive_read_free(a);
  }



//-------------------------------------------------------------------------------
int createOutputFile(int date_to_process, int nprovs_platform_id, char *nprovs_platform_name, int in_id)
  {
  int     n, plat, retval, out_id, dim_id, var_id;
  int     in_date_group_id;
  int     in_platform_name, in_platform_dir_name, in_platform_type, in_platform_id;
  int     out_platform_name, out_platform_dir_name, out_platform_type, out_platform_id;
  int     num_dims, num_variables, num_attributes, recdim;
  int     platform_dim, dimid_platform[1];
  int     num_groups, group_ids[100];
  int     in_num_platforms, out_num_platforms, out_plat_num;
  int     i4val;
  char    attr_name[NC_MAX_NAME];
  char    *string[1];
  char    copy_string[100], platform_dir_name[100], date_group_name[100];
  size_t  dim_len;
  size_t  in_index[1], out_index[1], num_vals[1];

  // Create the output netCDF file

  retval = nc_create("out.file", NC_NETCDF4, &out_id);

  if (retval != NC_NOERR)
    {
    printf("\n\n*** ERROR ***\n\n");
    printf("The output NPROVS collocation netCDF file could not be created.\n");
    printf("netCDF Error Code:  %d\n", retval);
    printf("Execution is stopping.\n\n");
    exit(1);
    }

  // Obtain the number of dimensions, attributes and variables from the input file

  ncinquire(in_id, &num_dims, &num_variables, &num_attributes, &recdim);

  // Copy the global attributes

  for (n=0; n<num_attributes; n++)
    {
    retval = nc_inq_attname(in_id, NC_GLOBAL, n, attr_name);
    retval = nc_copy_att(in_id, NC_GLOBAL, attr_name, out_id, NC_GLOBAL);
    }

  // Read the number of platforms

  retval = nc_inq_dimid(in_id, "Num_Platforms", &dim_id);
  retval = nc_inq_dimlen(in_id, dim_id, &dim_len);

  in_num_platforms = (int)dim_len;

  printf("Number of input platforms:  %d\n", in_num_platforms);

  // Get the input file platform variables ids

  retval = nc_inq_varid(in_id, "platform_name", &in_platform_name);
  retval = nc_inq_varid(in_id, "platform_dir_name", &in_platform_dir_name);
  retval = nc_inq_varid(in_id, "platform_type", &in_platform_type);
  retval = nc_inq_varid(in_id, "platform_id", &in_platform_id);

  // Count the number of input platforms that are not the same as the nprovs_platform_id

  out_num_platforms = 0;

  for (plat=0; plat<in_num_platforms; plat++)
    {
    in_index[0] = plat;
    num_vals[0] = 1;

    retval = nc_get_var1_int(in_id, in_platform_id, in_index, &i4val);

    if (i4val != nprovs_platform_id)
      out_num_platforms++;
    }  // for (plat=0...


  // Define the platform variables in the output file

  retval = nc_def_dim(out_id, "Num_Platforms", (out_num_platforms+1), &platform_dim);
  dimid_platform[0] = platform_dim;

  retval = nc_def_var(out_id, "platform_name", NC_STRING, 1, dimid_platform, &out_platform_name);
  retval = nc_def_var(out_id, "platform_dir_name", NC_STRING, 1, dimid_platform, &out_platform_dir_name);
  retval = nc_def_var(out_id, "platform_type", NC_INT, 1, dimid_platform, &out_platform_type);
  retval = nc_def_var(out_id, "platform_id", NC_INT, 1, dimid_platform, &out_platform_id);

  // Copy the platform information

  out_plat_num = -1;

  for (plat=0; plat<in_num_platforms; plat++)
    {
    in_index[0] = plat;
    num_vals[0] = 1;

    retval = nc_get_var1_int(in_id, in_platform_id, in_index, &i4val);

    if (i4val != nprovs_platform_id)
      {
      out_plat_num++;
      out_index[0] = out_plat_num;

      retval = nc_put_var1_int(out_id, out_platform_id, out_index, &i4val);

      retval = nc_get_var1_int(in_id, in_platform_type, in_index, &i4val);
      retval = nc_put_var1_int(out_id, out_platform_type, out_index, &i4val);

      retval = nc_get_var1_string(in_id, in_platform_name, in_index, (char**)copy_string);
      retval = nc_put_var1_string(out_id, out_platform_name, out_index, (const char **)copy_string);

      retval = nc_get_var1_string(in_id, in_platform_dir_name, in_index, (char**)copy_string);
      retval = nc_put_var1_string(out_id, out_platform_dir_name, out_index, (const char **)copy_string);
      }  // if (i4val != nprovs_platform_id...
    }  // for (plat=0...

  // Add the platform information

  out_index[0] = out_num_platforms;

  retval = nc_put_var1_int(out_id, out_platform_id, out_index, &nprovs_platform_id);

  i4val = 301;
  retval = nc_put_var1_int(out_id, out_platform_type, out_index, &i4val);

  string[0] = nprovs_platform_name;
  retval = nc_put_var1_string(out_id, out_platform_name, out_index, (const char **)string);

  sprintf(platform_dir_name, "%s_%d", nprovs_platform_name, nprovs_platform_id);
  for (int i=0; i<strlen(platform_dir_name); i++)
    if (platform_dir_name[i] == ' ')
      platform_dir_name[i] = '_';
  string[0] = platform_dir_name;
  retval = nc_put_var1_string(out_id, out_platform_dir_name, out_index, (const char **)string);

  // Add the date group and a subgroup within it for the platform

  retval = nc_inq_grps(in_id, &num_groups, group_ids);
  in_date_group_id = group_ids[0];

  retval = nc_inq_grpname(in_date_group_id, date_group_name);
  retval = nc_def_grp(out_id, date_group_name, &out_date_group_id);

  retval = nc_def_grp(out_date_group_id, platform_dir_name, &mirs_id);

  // Add the group attributes

  retval = nc_put_att_text(mirs_id, NC_GLOBAL, "Platform_Data_Source", (size_t)(strlen("MIRS")), "MIRS");

  short i2val = (short)nprovs_platform_id;
  retval = nc_put_att_short(mirs_id, NC_GLOBAL, "Platform_ID", NC_SHORT, 1, &i2val);

  i2val = (short)301;
  retval = nc_put_att_short(mirs_id, NC_GLOBAL, "Platform_Type", NC_SHORT, 1, &i2val);

  retval = nc_put_att_text(mirs_id, NC_GLOBAL, "Platform_Name", (size_t)(strlen(nprovs_platform_name)), nprovs_platform_name);
  retval = nc_put_att_text(mirs_id, NC_GLOBAL, "Platform_NPROVS_Source_Name", (size_t)(strlen(nprovs_platform_name)), nprovs_platform_name);

  return out_id;
  }



//-------------------------------------------------------------------------------
int copyAttributes(int in_id, int out_id)
  {
  int     attributes_copied;
  int     retval;
  char    *attr_string;
  size_t  attr_length;

  attributes_copied = FALSE;

  // Copy the creator email

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "creator_email", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "creator_email", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "creator_email", attr_length, attr_string);

  free(attr_string);

  // Copy the creator name

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "creator_name", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "creator_name", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "creator_name", attr_length, attr_string);

  free(attr_string);

  // Copy the creator url

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "creator_url", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "creator_url", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "creator_url", attr_length, attr_string);

  free(attr_string);

  // Copy the instrument

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "instrument", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "instrument", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "instrument", attr_length, attr_string);

  free(attr_string);

  // Copy the keywords

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "keywords", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "keywords", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "keywords", attr_length, attr_string);

  free(attr_string);

  // Copy the naming authority

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "naming_authority", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "naming_authority", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "naming_authority", attr_length, attr_string);

  free(attr_string);

  // Copy the platform

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "platform", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "platform", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "platform", attr_length, attr_string);

  free(attr_string);

  // Copy the processing level

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "processing_level", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "processing_level", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "processing_level", attr_length, attr_string);

  free(attr_string);

  // Copy the production environment

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "production_environment", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "production_environment", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "production_environment", attr_length, attr_string);

  free(attr_string);

  // Copy the production site

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "production_site", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "production_site", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "production_site", attr_length, attr_string);

  free(attr_string);

  // Copy the publisher name

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "publisher_name", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "publisher_name", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "publisher_name", attr_length, attr_string);

  free(attr_string);

  // Copy the publisher email

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "publisher_email", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "publisher_email", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "publisher_email", attr_length, attr_string);

  free(attr_string);

  // Copy the publisher url

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "publisher_url", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "publisher_url", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "publisher_url", attr_length, attr_string);

  free(attr_string);

  // Copy the references

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "references", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "references", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "references", attr_length, attr_string);

  free(attr_string);

  // Copy the standard name vocabulary

  retval = nc_inq_attlen(in_id, NC_GLOBAL, "standard_name_vocabulary", &attr_length);

  attr_string = (char*)malloc((int)attr_length * sizeof(char));

  retval = nc_get_att_text(in_id, NC_GLOBAL, "standard_name_vocabulary", attr_string);
  retval = nc_put_att_text(out_id, NC_GLOBAL, "standard_name_vocabulary", attr_length, attr_string);

  free(attr_string);

  attributes_copied = TRUE;

  return attributes_copied;
  }



//-------------------------------------------------------------------------------
void copyPreviousPlatforms(int in_id, int out_id, int platform_id)
  {
  int   grp, retval, num_groups, in_date_group;
  int   group_ids[1000];
  short in_group_id;

  printf("\nCopying data from previous platforms...\n");

  // Loop through the groups in the input date group

  retval = nc_inq_grps(in_id, &num_groups, group_ids);
  in_date_group = group_ids[0];

  retval = nc_inq_grps(in_date_group, &num_groups, group_ids);

  for (grp=0; grp<num_groups; grp++)
    {
    in_group_id = -32768;
    retval = nc_get_att_short(group_ids[grp], NC_GLOBAL, "Platform_ID", &in_group_id);

    if (in_group_id != platform_id)
      copyNetCDFGroup(in_id, out_id, group_ids[grp], out_date_group_id);
    }  // for (grp=0...
  }



//---------------------------------------------------------------------
void unpackGranuleDateAndTime(char *time_string, int* date, int* time)
  {
  int  i;
  char year[5], month[3], day[3], hour[3], minute[3], second[3];

  for (i=0; i<4; i++)
    year[i] = time_string[i];

  for (i=0; i<2; i++)
    {
    month[i]  = time_string[i+5];
    day[i]    = time_string[i+8];
    hour[i]   = time_string[i+11];
    minute[i] = time_string[i+14];
    second[i] = time_string[i+17];
    }

  year[4]   = '\0';
  month[2]  = '\0';
  day[2]    = '\0';
  hour[2]   = '\0';
  minute[2] = '\0';
  second[2] = '\0';

  *date = (atoi(year) * 10000) + (atoi(month) * 100) + atoi(day);
  *time = (atoi(hour) * 10000) + (atoi(minute) * 100) + atoi(second);
  }



//----------------------------------------------------------------------
void addFileToHash(const char *name)
  {
  struct FileEntry *s;
  HASH_FIND_STR(collocated_files_hash, name, s);

  if (s == NULL)
    {
    s = (struct FileEntry *)malloc(sizeof(struct FileEntry));
    strncpy(s->filename, name, sizeof(s->filename));
    HASH_ADD_STR(collocated_files_hash, filename, s);
    }
  }

// end of file