/**
  $Id:$
-----------------------------------------------------------------------

  @copyright
     (©) Copyright 2006 by GATS, Inc.,
     11864 Canon Blvd, Suite 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.

-----------------------------------------------------------------------

 @file:  Level0DataInput.cpp

 @author:  John Burton <john@gats-inc.com>

 @datecreated:    Thu May  4 17:01:31 2006

-----------------------------------------------------------------------

 Modification History:

  $Log:$

 @brief Reads the Level 0 SOFIE Instrument data.  
 
 Currently the only option is from an ASCII file 
 
 @TODO Add Capability to read Solar Image Data, Detector names are hard coded, Add Filter T names
  
*/
//-----------------------------------------------------------------------
//
//-----------------------------------------------------------------------
// Include Files:
//-----------------------------------------------------------------------
//

#include "ConfigFile.h"
#include "EventVar.h"
#include "EventVarVect.h"
#include "Level0DataInput.h"
#include "Lvl0_Reader.h"
#include "SofieDBinput.h"
#include "DBInputParam.h"
#include "GATS_Utilities.hpp"
#include "GATS_DB.h"
#include "GATS_DB_mysql.h"
#include "SofieDBinput.h"
#include "SofieDBAdjust.h"

#include <iostream>
#include <fstream>
#include <cassert> 
#include <vector>
//
//-----------------------------------------------------------------------
// Defines and Macros:
//-----------------------------------------------------------------------
//



//
//-----------------------------------------------------------------------
// Global Variables:
//-----------------------------------------------------------------------
//



//
//-----------------------------------------------------------------------
// Utility Routines:
//-----------------------------------------------------------------------
//void fillSigNames(std::vector<std::string> &A);

void fillFiltNames(vector<string> &Names);

using namespace gatsDBpp;
using namespace std;


int Level0DataInput(Event& L0, Event& L1, Event& Tmp, Event& SD, ConfigFile& cf)
{

    string filename;
    string name;
    string errMsg;
    Lvl0_Reader lvl0Read;
    
    Lvl0FileHeader      Aheader;
    DetectorSignals     ADetectors; 
    SunSensorData       ASunSensor; 

    FilTSignal          FilTem;
    DetectorTemperature detectorTem;
    DetectorAtten       AttenSettings;
    BalanceTimes        balTimes;
    string              logentry;
    
    int EventNumber;            
    string EventType; 
    int ret_code = 0;
    
    long i;
    double eventStart = 0.0;
     
    EventVar <double> DetSignal;  
    EventVar <double> FilterSignal;     
    EventVar <double> DetTem;     
    
    vector <string> SignalNames;
    vector <string> FilterHolderNames;
 
    EventVarVect <double> eventVect;
    EventVarVect <int> eventIntVect;

    const string MODULE_NAME = "Level0DataInput";
    

    SignalNames = cf.GetStrValues("Common","SignalNames");
    
    fillFiltNames(FilterHolderNames);
    
    bool EventExists = false;
    
    int useDatabase;
       
    try {
      
        useDatabase = (cf.GetIntValues(MODULE_NAME, "UseDatabase") )[0];
        
        if (useDatabase) 
            {
            
            string user   = (cf.GetStrValues(MODULE_NAME, "User") )[0];
            string passwd = (cf.GetStrValues(MODULE_NAME, "Passwd") )[0];
            string dbName = (cf.GetStrValues(MODULE_NAME, "Database_Name") )[0];
            string dbURL  = (cf.GetStrValues(MODULE_NAME, "URL_Name") )[0];
        
            GATS_DB_mysql dbConn(user.c_str(), passwd.c_str(), dbName.c_str(),dbURL.c_str() );
            SofieDBAdjust dbAdjust(dbConn);
            
            dbAdjust.UseGMTimeZone();
            
	        logentry = string("Using database: ") + dbName;
  	        L1.addLogEntry(logentry);
	        logentry = string("Using host: ") + dbURL;
  	        L1.addLogEntry(logentry);
        
            DBInputParam dbParam(MODULE_NAME, &cf, &dbConn);
            
            lvl0Read.Read(dbParam, cf, L0.getEventNumber());
            Aheader = lvl0Read.getHeader(); 

//            EventExists = lvl0Read.hasData();

            if (!lvl0Read.hasData())
                throw runtime_error("Event does not exist for this version of the Level 0 data.");   
            
            }
        else 
            {
            
            errMsg = string("Level0DataInput Error: The option to read from file has been discontinued");
            L1.addLogEntry(errMsg);
            throw runtime_error(errMsg);

            }
            
//         if (!EventExists)
//             throw runtime_error("Event does not exist for this version of the Level 0 data.");   


//      Transfer Event Header Information
     
        L0.setOrbitNumber(Aheader.getOrbitNumber() );
        EventType = Aheader.getEventType();
        L0.setSRSSFlag(EventType[3]);   // temporary fix. Should make it more robust after end-to-end test

	
	    logentry = string("Sunset/Sunrise flag: ") + 
  		GATS_Utilities::ConvertToString(L0.getSRSSFlag());
  	    cerr << logentry << endl;
  	    L1.addLogEntry(logentry);

        eventStart = Aheader.getEventStart();
        L0.setEventStartTime(eventStart);
        L0.setEventStopTime(Aheader.getEventEnd());

        L0.setAtmosStartTime(Aheader.getAtmosStart());
        L0.setAtmosStopTime(Aheader.getAtmosEnd());

        L0.setSolarScanStartTime(Aheader.getSolarScanStart());
        L0.setSolarScanStopTime(Aheader.getSolarScanEnd());

//      Copy the "header information" in L0 to the Event variables Tmp and L1  
      
        L1 = L0;
        Tmp = L0;

//      Transfer Balance Maneuver Start and End Times
/*

The balance start and stop times are now absolute times so in order for it
to be used properly we must subtract off the eventStart before
storing in the event class.

LED   06/30/2010


*/

        balTimes = lvl0Read.getBalanceTimes();
        EventVar <double> balanceStart(1);
        balanceStart[0] = balTimes.getStartTime() - eventStart;     // Subtract epoch is New since balance in event ancillary table
        balanceStart.setName("L0_BalanceStartTime");
        L0.addEventVar(balanceStart);
        EventVar <double> balanceEnd(1);
        balanceEnd[0] = balTimes.getEndtTime() - eventStart;   // Subtract epoch is New since balance in event ancillary table

// LED 02/04/2011 added 1 second to the balance end time to account for a bad value in the
// config table for Level 0
        balanceEnd[0] += 1.0;
// end LED
        balanceEnd.setName("L0_BalanceEndTime");
        L0.addEventVar(balanceEnd);

//      Transfer Detector Data
        
        ADetectors = lvl0Read.getDetectorData(); 
        EventVar <double> timeArray("L0_DetectorTimes", ADetectors.get_times());
        timeArray = timeArray - eventStart;   // Subtract Unix Epoch offset
        L0.addEventVar(timeArray);
        
        eventVect.setName("L0_DetectorSignals");
        DetSignal.resize(ADetectors.size() );
        
        assert(ADetectors.num_of_signals() == static_cast<long>(SignalNames.size()) );
        
        for(i = 0; i < ADetectors.num_of_signals(); i++)
// for(i = 0; i < 16; i++)

	        {
	        DetSignal = EventVar <double> ("", ADetectors.get_detector_voltage(i) ); 
/*
for(int j=0; j<(int)timeArray.size(); ++j) 
  if(timeArray[j] >= balanceStart[0] && timeArray[j] <= balanceEnd[0]) 
   std::cout << timeArray[j] << "   " << DetSignal[j] <<  std::endl;
   
std::cout << "&" << std::endl;
*/
	        DetSignal.setName(SignalNames[i]);
	        eventVect.addEventVar(DetSignal);
//          cerr << "SignalNames[" << i << "] = " << SignalNames[i] << "\n";  
	        }
//exit(23);
            
        L0.addEventVar(eventVect);

// Added by GJP on 2/22/2011 to output raw L0 data for HU.  HU will analyze
// the uncorrected data to determine the signal characteristics of bands
// 3 and 4.
/*
	char myStr[200];
	ofstream myFILE;
	sprintf(myStr, "L0Data_Event%d.tsv", L0.getEventNumber());
	myFILE.open(myStr);
	sprintf(myStr, "%f\t%f", balanceStart[0], balanceEnd[0]);
	myFILE << myStr << endl;
	myFILE.flush();
	sprintf(myStr, "%d", timeArray.size());
	myFILE << myStr << endl;
	myFILE.flush();
	myFILE << "Detector_Timestamp\tBand_3\tBand_4" << endl;
	for (i = 0; i < timeArray.size(); i++)
	{
		sprintf(myStr, "%f\t%f\t%f", timeArray[i], eventVect[2][i], eventVect[3][i]);
		myFILE << myStr << endl;
		myFILE.flush();
	}
	myFILE.close();
*/
/*
// Added by GJP for plotting of detectors during the balance on 2/16/2011
		int startIndex    = 0;
		int endIndex   = 0;
		for (i = 0; i < myTimeArray.size(); i++)
		{
			if (myTimeArray[i] <= balTimes.getStartTime() )
			{
				startIndex = i;
			}
			else if (myTimeArray[i] <= (balTimes.getEndtTime()) )
			{
				endIndex = i + 1;
			}
		}
		cout << "Indices = " << startIndex << "\t" << endIndex << endl;

		valarray <double> valTime(endIndex - startIndex);
		EventVar <double> myTime;
		for (i = startIndex; i < endIndex; i++)
		{
			valTime[i-startIndex] = myTimeArray[i];
		}
		myTime = EventVar <double> ("", valTime);
		myTime.setName("L0_EventTime");

		valarray <double> valSignal(endIndex - startIndex);
		EventVar <double> mySignal;
		EventVarVect <double> mySignals;
		mySignals.setName("L0_DetectorSignals");
		std::string myName;
		for (i = 2; i < 16; i++)
		{
			myName = "Band " + GATS_Utilities::ConvertToString(i);
			for (int j = startIndex; j < endIndex; j++)
			{
				valSignal[j-startIndex] = eventVect[i][j];
			}
			mySignal.setName(myName);
			mySignal = EventVar <double> ("", valSignal);
			mySignals.addEventVar(mySignal);
		}

		cout << "Before data output" << endl;
		for (i = 0; i < myTime.size(); i++)
		{
			printf("%f", myTime[i]);
			//cout << myTime[i] << "\t";
			for (int j = 0; j < 14; j++)
			{
				printf("\t%f", mySignals[j][i]);
				//cout << mySignals[j][i] << "\t";
			}
			cout << endl;
		}
		cout << "After data output" << endl;

		mySignals.Plot("Balance Signals", "Signals during the balance period", myTime);
*/

//      Transfer Solar Tracking Data
            
        ASunSensor = lvl0Read.getSunSensorData();
        EventVar <double> trackerTime("L0_SolarTrackerTimes", ASunSensor.getTime() );

        trackerTime = trackerTime - eventStart;   // Subtract Unix Epoch offset
        L0.addEventVar(trackerTime);
        
        EventVar <double> eventVar("L0_SolarTrackXLow", ASunSensor.getXLow());
        L0.addEventVar(eventVar);

        eventVar = EventVar <double> ("", ASunSensor.getXHigh() );
        eventVar.setName("L0_SolarTrackXHigh");
        L0.addEventVar(eventVar);

        eventVar = EventVar <double> ("", ASunSensor.getYLow() );
        eventVar.setName("L0_SolarTrackYLow");
        L0.addEventVar(eventVar);

        eventVar = EventVar <double> ("", ASunSensor.getYHigh() );
        eventVar.setName("L0_SolarTrackYHigh");
        L0.addEventVar(eventVar);

        eventVar = EventVar <double> ("", ASunSensor.getElev() );
        eventVar.setName("L0_MirrorElevation");        
        L0.addEventVar(eventVar);

        eventVar = EventVar <double> ("", ASunSensor.getAzim() );
        eventVar.setName("L0_MirrorAzimuth");        
        L0.addEventVar(eventVar);

        EventVar <int>  eventIntVar ("L0_SolarTrackerStatus", ASunSensor.getStatus() );
        L0.addEventVar(eventIntVar);

// Added by GJP on 2/22/2011 to output raw sunsensor data for HU.  HU will 
// combine this data with the detector uncorrected data to determine the
// signal characteristics of bands 3 and 4.
/*
		EventVar <double> XLow;
		EventVar <double> XHigh;
		EventVar <double> YLow;
		EventVar <double> YHigh;
		EventVar <int> status;
		L0.getEventVar("L0_SolarTrackXLow", XLow);
		L0.getEventVar("L0_SolarTrackXHigh", XHigh);
		L0.getEventVar("L0_SolarTrackYLow", YLow);
		L0.getEventVar("L0_SolarTrackYHigh", YHigh);
		L0.getEventVar("L0_SolarTrackerStatus", status);

		char myStr1[200];
		ofstream myFILE1;
		sprintf(myStr1, "TrackingData_Event%d.tsv", L0.getEventNumber());
		myFILE1.open(myStr1);
		sprintf(myStr1, "%f\t%f", balanceStart[0], balanceEnd[0]);
		myFILE1 << myStr1 << endl;
		myFILE1.flush();
		sprintf(myStr1, "%d", trackerTime.size());
		myFILE1 << myStr1 << endl;
		myFILE1.flush();
		myFILE1 << "SunSensor_Timestamp\tXLow\tXHigh\tYLow\tYHigh\tStatus" << endl;
		for (i = 0; i < trackerTime.size(); i++)
		{
			sprintf(myStr1, "%f\t%f\t%f\t%f\t%f\t%d", trackerTime[i], XLow[i], XHigh[i], YLow[i], YHigh[i], status[i]);
			myFILE1 << myStr1 << endl;
			myFILE1.flush();
		}
		myFILE1.close();
*/
//      Transfer Solar Image/Pixel Information
        
//        SolImag   = lvl0Read.getSolarImageData(); 

        EventVar <double> imageTime("L0_SolarImageTimes",ASunSensor.getTime() );
        
        imageTime = imageTime - eventStart;   // Subtract Unix Epoch offset     
        L0.addEventVar(imageTime);

        eventIntVect.clear();                
        eventIntVect.setName("L0_SolarImages");
//        EventVar <int> SolarImageSignal(SolarImgSampleSize); 
        
        for(i = 0; i < NSums; i++)
            {
	    EventVar<int> SumsData("",ASunSensor.getSumsData(i));
	    eventIntVect.addEventVar(SumsData);
            }  
            
        L0.addEventVar(eventIntVect);
                          
//      Transfer Filter Temperature Data 
                           
        FilTem    = lvl0Read.getFilterTemperatureData();                    

//         EventVar <double> hskpTime("L0_HousekeepingTimes", FilTem.getTime() );           
//         hskpTime = hskpTime - eventStart;   // Subtract Unix Epoch offset     
//         L0.addEventVar(hskpTime);
         

        assert(FilTem.num_of_signals() == static_cast<long>(FilterHolderNames.size()) );
        eventVect.clear();        
        eventVect.setName("L0_FilterTemperatures");
        FilterSignal.resize(FilTem.size() );
        
        for(i = 0; i < FilTem.num_of_signals(); i++)
            {

            FilterSignal = EventVar <double> ("", FilTem.getTemperature(i) ); 
            FilterSignal.setName(FilterHolderNames[i] );
            eventVect.addEventVar(FilterSignal);
            
            }
        L0.addEventVar(eventVect);

//      Transfer Detector Temperature Data 
                           
        detectorTem = lvl0Read.getDetectorTemperatures();                    

        EventVar <double> hskpTime("L0_HousekeepingTimes", detectorTem.getTime() );           
        hskpTime = hskpTime - eventStart;   // Subtract Unix Epoch offset     
        L0.addEventVar(hskpTime);         

        eventVect.clear();        
        eventVect.setName("L0_DetectorTemperatures");
        DetTem.resize(detectorTem.size() );
        
        for(i = 0; i < detectorTem.num_of_signals(); i++)
            {

            DetTem = EventVar <double> ("", detectorTem.getTemperature(i) ); 
            name = SignalNames[i] + "_DetectorTemperature";
            DetTem.setName(name);
            eventVect.addEventVar(DetTem);
            
            }
        L0.addEventVar(eventVect);

//      Transfer Attenuator Settings

        AttenSettings = lvl0Read.getAttenuatorData();        
        EventVar <double> attenuators(AttenSettings.size());     
        attenuators.setName("L0_AttenuatorSettings"); 
        for(i = 0; i <  AttenSettings.size(); i++)
            attenuators[i] =  AttenSettings[i];
                
        L0.addEventVar(attenuators);

//      Transfer Balance Maneuver Start and End Times
/*

The balance start and stop times are now absolute times so in order for it
to be used properly we must subtract off the eventStart before
storing in the event class.

LED   06/30/2010


*/
//        balTimes = lvl0Read.getBalanceTimes();
//        EventVar <double> balanceStart(1);
//        balanceStart[0] = balTimes.getStartTime() - eventStart;     // Subtract epoch is New since balance in event ancillary table    
//        balanceStart.setName("L0_BalanceStartTime");     
//        L0.addEventVar(balanceStart);
//        EventVar <double> balanceEnd(1); 
//        balanceEnd[0] = balTimes.getEndtTime() - eventStart;   // Subtract epoch is New since balance in event ancillary table            
//        balanceEnd.setName("L0_BalanceEndTime");             
//        L0.addEventVar(balanceEnd);
                   
//std::cout << balanceStart[0] << "    " << balanceEnd[0] << std::endl; exit(23);
        } catch (exception const& ex) {
   
        errMsg = "Exception encountered in Level0DataInput routine: " + string(ex.what());
   
	L1.addLogEntry(errMsg);
	ret_code = -100;        
        }
        
    return ret_code;
  
//  std::cerr << "In Level0DataInput Version 1.1\n";
}


void fillFiltNames(vector<string> &Names)
//
//  Temporary Function for filling the vector of Filter Holder Temperature names.
//  Will eventually be replaced by a call to the database
//
    {
    Names.push_back("Filter_Holder_1");
    Names.push_back("Filter_Holder_2");
    Names.push_back("Filter_Holder_3");
    Names.push_back("Filter_Holder_4");
    Names.push_back("Filter_Holder_5");
    Names.push_back("Filter_Holder_6");
    Names.push_back("Filter_Holder_7");
    Names.push_back("Filter_Holder_8");
    
    }