/***************************************************************************
 *   Copyright (C) 2005 by Nicolas PASCAL                                  *
 *   nicolas.pascal@icare.univ-lille1.fr                                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *---------------
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include "omifiledata.h"


const string OMIFileData::latitude_sds_name="Latitude";
const string OMIFileData::longitude_sds_name="Longitude";
const string OMIFileData::time_sds_name="Time";
const float OMIFileData::colocation_tolerance=0.05;

OMIFileData::OMIFileData(const string &name,const string & mode):
    FileData(name,mode),SatelliteFileData(name,mode),HDF5FileData(name,mode) {
    init();
}
void OMIFileData::init() {

    lat_data=NULL;
    lon_data=NULL;
    time_data=NULL;

    // extract the acquisition date from the file name
    string short_filename = get_tail(get_name());
    parse_filename(short_filename);

    HDF5FileData::open_data_file();
    vector<int> v;
    lat_lon_index_max =this->get_dataset_dimension(latitude_sds_name);
    track_size=1;
    for(uint i=0; i<lat_lon_index_max.size(); i++) track_size*=lat_lon_index_max[i];
    if(v.size()==0) track_size=0;
    HDF5FileData::close_data_file();

}
OMIFileData::~OMIFileData() {
    free_geolocation_data();
    HDF5FileData::close_data_file();
}

void OMIFileData::check_filename( const string& short_filename ) const {
}
void OMIFileData::parse_filename( const string& short_filename ) {
    check_filename(short_filename); // throw a parse_IIR_filename_error if the filename doesn't matches the pattern
}
const int OMIFileData::get_nearest_point_index( const float & lat, const float & lon, const double & lidar_shot_time) {
    int nearest_index=-1;

    bool data_already_loaded=is_geolocation_data_loaded();
    if (!data_already_loaded)
        load_geolocation_data();

    int nb_pts = track_size;
    float* p_lat = lat_data;
    float* p_lon = lon_data;

    // search for the nearest point
    double delta;
    if (nb_pts!=0) {
        nearest_index=0;
        delta=sqrt( pow(*(p_lat+0)-lat,2) + pow(*(p_lon+0)-lon,2) );
        double current_delta;
        for (int i = 1 ; i<nb_pts ; ++i) {
            current_delta=sqrt(  pow(*(p_lat+i)-lat,2) + pow(*(p_lon+i)-lon,2) );
            if (current_delta<delta) {
                delta=current_delta;
                nearest_index=i;
            }
        }
    }
    if (!data_already_loaded)
        free_geolocation_data();
    return nearest_index;
}

const bool OMIFileData::get_index( const float & lat, const float & lon, const double & time, int * nearest_pix_idx, const float coloc_tolerance ) {
    nearest_pix_idx[0]=-1; nearest_pix_idx[1]=-1; // default output

    bool data_already_loaded=is_geolocation_data_loaded();
    if (!data_already_loaded)
        load_geolocation_data();

    double delta_lat,delta_lon,delta,best_delta;
    delta_lat=delta_lon=delta=best_delta=9999.; // 9999 is bigger than the biggest delta that can be
    int _nearest_pix_idx[]={-1,-1};

    /*** use a generic search on sorted datas ***/
    // bounds of the colocation frame
    float lat_min=lat-coloc_tolerance; // lower latitude acceptable
    float lon_min=lon-coloc_tolerance; // lower longitude acceptable
    PixelType pix_min(&lat_min,&lon_min,vector<int>(0));
    float lat_max=lat+coloc_tolerance; // biggest latitude acceptable
    float lon_max=lon+coloc_tolerance; // biggest longitude acceptable
    PixelType pix_max(&lat_max,&lon_max,vector<int>(0));

    // set the range of colocated points candidates
    I_Pixel i_pix_min=lower_bound(v_pixel.begin(),v_pixel.end(),pix_min);
    I_Pixel i_pix_max=upper_bound(v_pixel.begin(),v_pixel.end(),pix_max);
//     cout<<"Pix Min ["<<i_pix_min->get_val()[0]<<","<<i_pix_min->get_val()[1]<<"]"<<endl;
//     cout<<"Pix Max ["<<i_pix_max->get_val()[0]<<","<<i_pix_max->get_val()[1]<<"]"<<endl;
//     cout<<"Distance "<<distance(i_pix_min,i_pix_max)<<endl;
    // cross the candidates to match the nearest one
    for (I_Pixel i_pix=i_pix_min;i_pix!=i_pix_max;++i_pix) {
      delta_lat=abs(i_pix->get_lat()-lat);
      delta_lon=abs(i_pix->get_lon()-lon);
      if (delta_lat<coloc_tolerance && delta_lon<coloc_tolerance) {
        // the pixel is in the colocalisation frame
//         cout<<"Possible point ("<<i_pix->get_lat()<<","<<i_pix->get_lon()<<") ["<<i_pix->get_val()[0]<<","<<i_pix->get_val()[1]<<"]"<<endl;
        delta=sqrt(pow(delta_lat,2)+pow(delta_lon,2));
        if (delta<best_delta) {
            best_delta=delta;
            _nearest_pix_idx[0]=i_pix->get_val()[0];
            _nearest_pix_idx[1]=i_pix->get_val()[1];
        }
      }
    }

    if (!data_already_loaded)
        free_geolocation_data();

    nearest_pix_idx[0]=_nearest_pix_idx[0];
    nearest_pix_idx[1]=_nearest_pix_idx[1];
    return (nearest_pix_idx[0]!=-1 && nearest_pix_idx[1]!=-1);
}
void OMIFileData::load_geolocation_data() {
    if (!is_geolocation_data_loaded()) {

        // read lat, lon data
        if (lat_data==NULL)
            lat_data=static_cast<float*>(read_data(static_cast<void*>(lat_data),latitude_sds_name.c_str(),NULL,NULL,NULL));
        if (lon_data==NULL)
            lon_data=static_cast<float*>(read_data(static_cast<void*>(lon_data),longitude_sds_name.c_str(),NULL,NULL,NULL));
        if (time_data==NULL)
            time_data=static_cast<double*>(read_data(static_cast<void*>(time_data),time_sds_name.c_str(),NULL,NULL,NULL));

        // build the sorted pixels list
        load_v_pixel();

    }
}

void OMIFileData::load_v_pixel()
{
    vector<int> sds_index(2); // indexes [y,x] of a pixel in a MODIS SDS
    int y_max=lat_lon_index_max[0],x_max=lat_lon_index_max[1];
    int buffer_idx=0; // linear index to access 2D lat/lon data arrays
    for (int y_idx=0;y_idx<y_max;++y_idx) {
        for (int x_idx=0;x_idx<x_max;++x_idx) {
        buffer_idx=y_idx*x_max+x_idx;
        sds_index[0]=y_idx;
        sds_index[1]=x_idx;
        v_pixel.push_back(PixelType(lat_data+buffer_idx,lon_data+buffer_idx,sds_index));
        }
    }
    sort(v_pixel.begin(),v_pixel.end());
}

const bool OMIFileData::get_index(const float &lat, const float& lon, int &nearest_pix_idx, const float coloc_tolerance)
{
    int nearest_pix_idx2[]={-1,-1};

    get_index(lat, lon, -1.0, nearest_pix_idx2, coloc_tolerance);
    if(nearest_pix_idx2[0]==-1 || nearest_pix_idx2[1]==-1) return false;

    int x_max=lat_lon_index_max[1];
    nearest_pix_idx=nearest_pix_idx2[0]*x_max+nearest_pix_idx2[1];

    return true;
}

const float OMIFileData::get_nearest_point_distance( const float & lat, const float & lon, const float coloc_tolerance ) {
    bool data_already_loaded=is_geolocation_data_loaded();
    if (!data_already_loaded)
        load_geolocation_data();

    int nearest_point_idx;
    double nearest_point_distance=-1.;
    if (get_index(lat,lon,nearest_point_idx,coloc_tolerance))
        // a point in the coincidence frame has been found
        nearest_point_distance=sqrt(pow(lat_data[nearest_point_idx]-lat,2) + pow(lon_data[nearest_point_idx]-lon,2));

    if (!data_already_loaded)
        free_geolocation_data();

    return nearest_point_distance;
}

const bool OMIFileData::contain_location(const float &lat,const float &lon, const double &tolerance){
  int nearest_idx=-1;
  return get_index(lat,lon,nearest_idx,colocation_tolerance);
}
const bool OMIFileData::contain_data( const float & lat, const float & lon, const double & time, const double &colocation_tolerance ) {
  return contain_location(lat,lon,colocation_tolerance)&&contain_time(time);
}