//////////////////////////////////////////////////////////////////////////
//
//       (C) Copyright 2002 by GATS, Inc.
//           11864 Canon Blvd., STE 101
//           Newport News, VA 23606     
//
//   All Rights Reserved. No part of this software or publication may be
//   reproduced, stored in a retrieval system, or transmitted, in any form
//   or by any means, electronic, mechanical, photocopying, recording, or
//   otherwise without the prior written permission of GATS, Inc.
// 
///////////////////////////////////////////////////////////////////////////
//
//
// Class: SGI_FileReader
//
// Filename:  SGI_FileReader.cpp
//
// Description:  contains methods and variables to read SGI file.
//               Refer to header file for more details.
//
// Author:      Y.Wang
//              (757)873-5920
//              <ywang@gats-inc.com>
//////////////////////////////////////////////////////////////////////////

#include <exception>
#include <stdexcept>
#include <string>
#include <sstream>
#include <fstream>
#include <iostream>
//#include <stream>
//#include <netcdf-3/netcdf.h>
#include <netcdf.h>
#include "SGI_FileReader.h"

using namespace std;

///////////////////////////////////////////////////////////////////////
//
// Method:  SGI_FileReader
//
// Description:  Default constructor.
//
//////////////////////////////////////////////////////////////////////////

SGI_FileReader::SGI_FileReader()
{
   BasicInitialize();
}

///////////////////////////////////////////////////////////////////////
//
// Method:  SGI_FileReader
//
// Description:  Class constructor.  Gives the class the name of the file
//               to be read.
//
// Inputs:  the_filename - The name of the file to be read.
//
//////////////////////////////////////////////////////////////////////////

SGI_FileReader::SGI_FileReader(const std::string &the_filename)
{
   //cout<<"Input File Name: "<<the_filename<<"\n";
   BasicInitialize();
   SetUp(the_filename);
}


///////////////////////////////////////////////////////////////////////
//
// Method:  SGI_FileReader
//
// Description:  Class constructor.  Gives the class the name of the file
//               to be read.
//
// Inputs:  the_filename - The name of the file to be read.
//
//////////////////////////////////////////////////////////////////////////

SGI_FileReader::SGI_FileReader(const std::string &the_filedir, const std::string &the_filename)
{
   //cout<<"Input File Name: "<<the_filename<<"\n";
   BasicInitialize();
   SetUp(the_filedir+the_filename);
}


///////////////////////////////////////////////////////////////////////
//
// Method:  ~SGI_FileReader
//
// Description:  Destructor.
//
//////////////////////////////////////////////////////////////////////////

SGI_FileReader::~SGI_FileReader()
{
   if(file_is_open)
   {
      nc_close(ncid);

      file_is_open = false;
      setup_attempted = false;
      setup_succeeded = false;

   }
}


///////////////////////////////////////////////////////////////////////
//
// Method:  SetUp
//
// Description:  Does everything that needs to be done before calling 
//               any of the other non-constructor/destructor methods.
//
// Inputs:  the_filename - The name of the SGI file to be read.
//
//////////////////////////////////////////////////////////////////////////

void SGI_FileReader::SetUp(const std::string &the_filename)
{
   //cout<<"filename in SetUp"<<the_filename<<"\n";

   if (setup_attempted == true)
   {
      cerr <<"ERROR:  Attempt to re-set-up the SGI file reader."<<endl;
      throw runtime_error("ERROR:  Attempt to re-set-up the SGI file reader.");
   }

   setup_attempted = true;

   filename = the_filename;
   cout<<"filename in SetUp"<<filename<<"\n";
   //cout<<"filename.c_str() in SetUp"<<filename.c_str()<<"\n";

   // Open the file.

   if (NC_NOERR != nc_open(filename.c_str(),
                           NC_NOWRITE,
                           &ncid))
   {
      cerr << "ERROR:  Unable to open SGI file for reading, " << endl
                    << "        " << filename.c_str() << endl;

      throw runtime_error("Error in SGI Reader");
   }


   // Then next few lines determine how many SGI records are in the file
   // so other methods can later tell when all the records have been read.

   if (NC_NOERR != nc_inq_dimid(ncid,
                                "date_dim",
                                &date_dim_id))
   {
      nc_close(ncid);

      cerr<< "ERROR:  Unable to get SC time dimension id.\n";
      throw runtime_error("ERROR:  Unable to get SC time dimension id");
   }

   
   if (NC_NOERR != nc_inq_dimlen(ncid,
                                 date_dim_id,
                                 &date_dim_len))
   {
      nc_close(ncid);

      cerr << "ERROR:  Unable to get SC time dimension length."<<endl;
      throw runtime_error("Unable to get SC time dimension length.");      
   }

   file_is_open = true;

   setup_succeeded = true;

   return;
}

///////////////////////////////////////////////////////////////////////
//
// Method:  BasicInitialize
//
// Description:  Initializes some data members of the class that need
//               initialization.  Done in this method so that the same
//               initialization can be done for each of the constructors.
//
//////////////////////////////////////////////////////////////////////////

void SGI_FileReader::BasicInitialize()
{
   file_is_open = false;
   setup_attempted = false;
   setup_succeeded = false;

   date_dim_len = 0;
   return;
}


/////////////////////////////////////////////////////////////////////
//
// Method: SGI_findRecord
// Description: Reads SGI records at given index (inputed)
/////////////////////////////////////////////////////////////////////
void SGI_FileReader::SGI_findRecord(long yyyyday,int &recordIndex) 
{
    int RecordCounter =-1;
    size_t  index[MAX_NC_VARS];
    long dateSGI;
    int endRecord,midRecord; 
    bool gotData;
    gotData = false;
    endRecord = date_dim_len-1;
    midRecord = (endRecord + RecordCounter)/2;
    while(endRecord >= RecordCounter + 1)
    { 
      midRecord = (endRecord + RecordCounter)/2;
     // Read in Date from SGI record #midRecord
      index[0]= midRecord; 
      if (NC_NOERR != nc_get_var1_long(ncid,0,index,&dateSGI))
      {
         cerr<<"ERROR:  Failed to read the Date from the SGI file."<<endl;
         throw runtime_error("ERROR:  Failed to read the Date from the SGI file.");
      }
      cout<<"midRecord,dateSGI ="<<midRecord<<","<<dateSGI<<"\n";
      cout<<"dateSGI = "<<dateSGI <<endl;
      if(yyyyday == dateSGI){
        RecordCounter = midRecord;
        gotData = true;
        break;
     }  
     if(yyyyday > dateSGI)
        {
	   RecordCounter = midRecord;
	}
     else
        {
           endRecord   =  midRecord;
        }
     //gotData = (RecordCounter >=0 && RecordCounter <= date_dim_len - 1);
   } //endwhile
   cout<<"endwhile\n";   
   if (gotData == false){
        //No SGI records found
	cerr<< "Error:Unable to get SGI records corresponding to "<<yyyyday<<endl ;
	exit(8);
    }
    recordIndex = RecordCounter;
    return;
}    


///////////////////////////////////////////////////////////////////////
//
// Method:  ReadSingle_SGI_Record
//
// Description:  Reads the next single SGI record.
//
// Outputs:  record - The record that is read.
//
//////////////////////////////////////////////////////////////////////////
void SGI_FileReader::ReadSingle_SGI_Record(int index_into_date_var,SGI_Single_Record &record)
{  
   size_t start[]=
    {index_into_date_var,0};

   long dateSGI;
   float ap;
   float kp_1,kp_2,kp_3,kp_4,kp_5,kp_6,kp_7,kp_8;
   float flux10_7;

   if (NC_NOERR != nc_get_var1_long( ncid, 0, start, &dateSGI))
      {
         cerr <<"ERROR:  Failed to read the Date from the SGI \n";
         throw runtime_error("ERROR:  Failed to read the Date from the SGI file");
      }
   record.Date = dateSGI;   

   if (NC_NOERR != nc_get_var1_float( ncid, 1,start, &ap))
      {
         throw runtime_error("ERROR:  Failed to read Ap from the SGI file");
      }

   record.Ap = ap;

   if (NC_NOERR != nc_get_var1_float( ncid, 2, start, &kp_1))
      {
         cerr<<"ERROR:  Failed to read the Kp_1 from the SGI file."<<endl;
         throw("ERROR:  Failed to read the Kp_1 from the SGI file.");
      }

   record.Kp[0]= kp_1;
   

   if (NC_NOERR != nc_get_var1_float( ncid, 3, start, &kp_2))
      {
         cerr<<"ERROR:  Failed to read the Kp_2 from the SGI file."<<endl;
         throw runtime_error("ERROR:  Failed to read the Kp_2 from the SGI file.");
      }

   record.Kp[1]= kp_2;
   
   if (NC_NOERR != nc_get_var1_float( ncid, 4, start, &kp_3))
      {
         cerr<<"ERROR:  Failed to read the Kp_3 from the SGI file."<<endl;
         throw runtime_error("ERROR:  Failed to read the Kp_3 from the SGI file.");
      }

   record.Kp[2]= kp_3;
   
   if (NC_NOERR != nc_get_var1_float( ncid, 5, start, &kp_4))
      {
         cerr<<"ERROR:  Failed to read the Kp_4 from the SGI file."<<endl;
         throw runtime_error("ERROR:  Failed to read the Kp_4 from the SGI file.");
      }

   record.Kp[3]= kp_4;
   
   if (NC_NOERR != nc_get_var1_float( ncid, 6, start, &kp_5))
      {
         cerr<<"ERROR:  Failed to read the Kp_5 from the SGI file."<<endl;
         throw runtime_error("ERROR:  Failed to read the Kp_5 from the SGI file.");
      }

   record.Kp[4]= kp_5;

   if (NC_NOERR != nc_get_var1_float( ncid, 7, start, &kp_6))
      {
         cerr<<"ERROR:  Failed to read the Kp_6 from the SGI file."<<endl;
         throw runtime_error("ERROR:  Failed to read the Kp_6 from the SGI file.");
      }

   record.Kp[5]= kp_6;
   
   if (NC_NOERR != nc_get_var1_float( ncid, 8, start, &kp_7))
      {
         cerr<<"ERROR:  Failed to read the Kp_7 from the SGI file."<<endl;
         throw runtime_error("ERROR:  Failed to read the Kp_7 from the SGI file.");
      }

   record.Kp[6]= kp_7;

   if (NC_NOERR != nc_get_var1_float( ncid, 9, start, &kp_8))
      {
         cerr<<"ERROR:  Failed to read the Kp_8 from the SGI file."<<endl;
         throw runtime_error("ERROR:  Failed to read the Kp_8 from the SGI file.");
      }

   record.Kp[7]= kp_8;
  
   if (NC_NOERR != nc_get_var1_float(ncid,10,start,&flux10_7))
      {
         cerr<<"ERROR:  Failed to read the flux from the SGI file."<<endl;
	 throw runtime_error("ERROR:  Failed to read the flux from the SGI file.");

      }
   record.flux10_7 = flux10_7;
 
   //record.flux10_7 = -999;
   return;
}

///////////////////////////////////////////////////////////////////////
//
// Method:  Read_SGI_RecordsToBuffer
//
// Description:  Reads all SGI records into a buffer.
//
// Outputs:  record_buffer - A list of records that is filled with the 
//                           desired number of records.
//
//////////////////////////////////////////////////////////////////////////

void SGI_FileReader::Read_SGI_RecordsToBuffer(
                           SGI_Record_Buffer &record_buffer)
{
   SGI_Single_Record record;
   short index_into_date_var;
   int records_2_read = date_dim_len;
   //logFile for test
   /*
   char logFileName[]="sgiReader.log";
   ofstream logFile(logFileName);
   */
   // Read the desired records and store them into the buffer.
   //Changed due to Inconsistency In Field Size SGI NetCDF File Date/SolarFlux -- CWB 20050314
   //Field Size Mismatch Fixed By TIMED MOC
   //if(date_dim_len < 90)
   //    records_2_read = date_dim_len - 3;
   for (int RecordCounter=0;RecordCounter<records_2_read; RecordCounter++)
   //for (int RecordCounter=0;RecordCounter<date_dim_len; RecordCounter++)
   {
     ReadSingle_SGI_Record(RecordCounter,record);
     record_buffer[record.Date] = record;
     //logFile << form("%d %ld %f %f %f %f %f\n",RecordCounter,
     //             record_buffer[record.Date].Date,record_buffer[record.Date].Ap,record_buffer[record.Date].Kp[0],record_buffer[record.Date].Kp[3],record_buffer[record.Date].Kp[7],record_buffer[record.Date].flux10_7);
   }		  
   return;
}

///////////////////////////////////////////////////////////////////////
//
// Method:  Read_SGI_RecordsToBuffer
//
// Description:  Reads all SGI records into a buffer.
//
// Outputs:  record_buffer - A list of records that is filled with the
//                           desired number of records.
//
//////////////////////////////////////////////////////////////////////////

void SGI_FileReader::Read_SGI_RecordsToBuffer()
{
   SGI_Single_Record record;
   short index_into_date_var;
   int records_2_read = date_dim_len;
   //logFile for test
   /*
   char logFileName[]="sgiReader.log";
   ofstream logFile(logFileName);
   */
   // Read the desired records and store them into the buffer.
   //Changed due to Inconsistency In Field Size SGI NetCDF File Date/SolarFlux -- CWB 20050314
   //Field Size Mismatch Fixed By TIMED MOC
   //if(date_dim_len < 90)
   //    records_2_read = date_dim_len - 3;
   for (int RecordCounter=0;RecordCounter<records_2_read; RecordCounter++)
   //for (int RecordCounter=0;RecordCounter<date_dim_len; RecordCounter++)
   {
     ReadSingle_SGI_Record(RecordCounter,record);
     record_buffer[record.Date] = record;

     if(RecordCounter==0) date_startdoy = record.Date;
     if(RecordCounter==records_2_read-1) date_enddoy = record.Date;

     //logFile << form("%d %ld %f %f %f %f %f\n",RecordCounter,
     //             record_buffer[record.Date].Date,record_buffer[record.Date].Ap,record_buffer[record.Date].Kp[0],record_buffer[record.Date].Kp[3],record_buffer[record.Date].Kp[7],record_buffer[record.Date].flux10_7);
   }
   return;
}

///////////////////////////////////////////////////////////////////////
//
// Method:  getBegJDN
//
// Description:  gets JDN value of Beginning record
//
// Outputs:  double: Julian day number
//   
//
//////////////////////////////////////////////////////////////////////////

double SGI_FileReader::getBegJDN()
{
   double stemp;
   int scal[7];
   doy2cal(date_startdoy, scal);
   cal2jdn(scal, stemp);

   return stemp;
}

///////////////////////////////////////////////////////////////////////
//
// Method:  getEndJDN
//
// Description:  gets JDN value of last record
//
// Outputs:  double: Julian day number
//
//
//////////////////////////////////////////////////////////////////////////

double SGI_FileReader::getEndJDN()
{
   double stemp;
   int scal[7];
   doy2cal(date_enddoy, scal);
   cal2jdn(scal, stemp);

   return stemp;
}

///////////////////////////////////////////////////////////////////////
//
// Method:  getKpValues
//
// Description:  fills Kp range for single day 
//
// Outputs:  float[8]
//
//
//////////////////////////////////////////////////////////////////////////

void SGI_FileReader::getKpValues(float *kpArray, long date, int index){
   for(int i=0; i<8; i++){
	kpArray[i+index] = record_buffer[date].Kp[i];
   }
   return;
}

///////////////////////////////////////////////////////////////////////
//
// Method:  getKpValues
//
// Description:  fills all 32 Kp values with values for a single day
//
// Outputs:  float[8]
//
//
//////////////////////////////////////////////////////////////////////////

void SGI_FileReader::getKpValues(float *kpArray){
   for(int i=0; i<8; i++){
        kpArray[i] = record_buffer[date_enddoy].Kp[i];
        kpArray[i+8] = record_buffer[date_enddoy].Kp[i];
        kpArray[i+16] = record_buffer[date_enddoy].Kp[i];
        kpArray[i+24] = record_buffer[date_enddoy].Kp[i];
   }
   return;
}