#include <stdio.h>

#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <iterator>
#include <functional>
#include <ext/functional>
#include <stdexcept>
#include <algorithm>

#include <TPRegexp.h>
#include <TObjArray.h>
#include <TObjString.h>

#include "filemanager.h"


void FileManager::AddDatasetInformation(const DatasetInformation & dataset_information)
{
    datasets_info.insert(std::make_pair(dataset_information.name, dataset_information));
}


void FileManager::InitDatasetInformation()
{
    const std::string data_path = "/gpfs/storage_2/atlas/atlasgroupdisk/phys-sm/data10_7TeV/NTUP_PROMPTPHOT";
    const std::string mc_path = "/gpfs/storage_2/atlas/atlasgroupdisk/phys-sm/mc09_7TeV/NTUP_PROMPTPHOT";

    DatasetInformation dataset_DATA;
    dataset_DATA.name = "DATA";
    dataset_DATA.regex = "data10_7TeV\\.([0-9]+)\\.physics";
    dataset_DATA.path = data_path;
    
    DatasetInformation dataset_DATAEGAMMA;
    dataset_DATAEGAMMA.name = "DATAEGAMMA";
    dataset_DATAEGAMMA.regex = "data10_7TeV\\.([0-9]+)\\.physics_Egamma";
    dataset_DATAEGAMMA.path = data_path;
    
    DatasetInformation dataset_DATAL1CALO;
    dataset_DATAL1CALO.name = "DATAL1CALO";
    dataset_DATAL1CALO.regex = "data10_7TeV\\.([0-9]+)\\.physics_L1Calo";
    dataset_DATAL1CALO.path = data_path;

    DatasetInformation dataset_MCJF17;
    dataset_MCJF17.name = "MCJF17";
    dataset_MCJF17.regex = "mc09_7TeV\\.([0-9]+)\\.JF17_pythia_jet_filter";
    dataset_MCJF17.path = mc_path;

    DatasetInformation dataset_MCGAMGAM15;
    dataset_MCGAMGAM15.name = "MCGAMGAM15";
    dataset_MCGAMGAM15.regex = "mc09_7TeV\\.([0-9]+)\\.Pythiagamgam15";
    dataset_MCGAMGAM15.path = mc_path;

    DatasetInformation dataset_MCGAMGAM7;
    dataset_MCGAMGAM7.name = "MCGAMGAM7";
    dataset_MCGAMGAM7.regex = "mc09_7TeV\\.([0-9]+)\\.Pythiagamgam7";
    dataset_MCGAMGAM7.path = mc_path;

    // special, better not use
    DatasetInformation dataset_GENERIC;
    dataset_GENERIC.name = "GENERIC";
    dataset_GENERIC.regex = "7TeV\\.([0-9]+)\\.";
    dataset_GENERIC.path = ".";
    

    AddDatasetInformation(dataset_DATA);
    AddDatasetInformation(dataset_DATAEGAMMA);
    AddDatasetInformation(dataset_DATAL1CALO);
    AddDatasetInformation(dataset_MCJF17);
    AddDatasetInformation(dataset_MCGAMGAM7);
    AddDatasetInformation(dataset_MCGAMGAM15);
    AddDatasetInformation(dataset_GENERIC);
}


FileManager::FileManager(const std::string datasetname)
{
    InitDatasetInformation();
    
    std::string dsn = datasetname;
    std::transform(dsn.begin(), dsn.end(),
		   dsn.begin(), ::toupper);

    std::map<std::string, DatasetInformation>::iterator iter = datasets_info.begin();
    iter = datasets_info.find(datasetname);
    if (iter != datasets_info.end())
    {
	dataset_info = iter->second;
    } else {
	dataset_info = datasets_info["GENERIC"];
	dataset_info.path = datasetname;
    }
    
    
    find_files();
    std::cout << "find " << database.size() << " runs" << std::endl;
}

FileManager::FileManager(const DatasetInformation & dataset_information)
 : dataset_info(dataset_information)
{
    find_files();
    std::cout << "find " << database.size() << " runs" << std::endl;
}


void FileManager::find_files()
{
    // this is an ugly C trick using a system call to find. Maybe it's better
    // to find a better (and portable) solution with boost::filesystem
    std::string command = "find " + dataset_info.path + " -name \\*root\\*";
    std::vector<std::string> output_find;
    FILE * f = popen(command.c_str(), "r" );
    if (f == 0) {
	std::cerr << "Could not execute\n";
        return;
    }
    const int BUFSIZE = 1000;
    char buf[BUFSIZE];
    while( fgets( buf, BUFSIZE,  f ) ) {
	output_find.push_back(buf);
	std::string buf_string(buf);
	std::string abs_filename(buf_string, 0, buf_string.size() + (buf_string[buf_string.size()-1] == '\n' ? -1 : 0));
	std::size_t ROOT_extension = abs_filename.find(".root");
	if (ROOT_extension == std::string::npos) {
	    std::cerr << "file " << abs_filename << " is not a ROOT file, ignored" << std::endl;
	}

	TPRegexp regex_runnumber(dataset_info.regex);
	TObjArray *regex_match = regex_runnumber.MatchS(abs_filename);
	if (regex_match->GetEntries() == 0)
	{
/*	    std::cerr << "can't find runnumber for file " 
	    << abs_filename << std::endl;*/
	    continue;
	}
	
	const TString runnumber_string =
	    static_cast<TObjString*>(regex_match->At(1))->GetString();
	
	if (not runnumber_string.IsDigit())
	{
	    std::cerr << "runnumber if not digits for file "
		      <<  abs_filename
		      << " match: " << runnumber_string << std::endl;
	    continue;
	}
	
	runnumber_id runnumber = runnumber_string.Atoi();

	database.insert(std::make_pair(runnumber, abs_filename));
    }
    pclose(f);
}

// returning iterators

FileManager::bi_iterator FileManager::get_iterator(runnumber_id runnumber) const
{
    return database.equal_range(runnumber);
}

FileManager::bi_iterator FileManager::get_iterator_all() const
{
    database_type::const_iterator lower = database.begin();
    database_type::const_iterator upper = database.end();
    return FileManager::bi_iterator(lower, upper);
}

FileManager::bi_iterator FileManager::get_iterator_from(runnumber_id from) const
{
    database_type::const_iterator lower = database.lower_bound(from);
    database_type::const_iterator upper = database.end();
    return FileManager::bi_iterator(lower, upper);
}

FileManager::bi_iterator FileManager::get_iterator_to(runnumber_id to) const
{
    database_type::const_iterator lower = database.begin();
    database_type::const_iterator upper = database.upper_bound(to);
    return FileManager::bi_iterator(lower, upper);
}

FileManager::bi_iterator FileManager::get_iterator_fromto(runnumber_id from, runnumber_id to) const
{
    database_type::const_iterator lower = database.lower_bound(from);
    database_type::const_iterator upper = database.upper_bound(to);
    return FileManager::bi_iterator(lower, upper);
}

// returning vector

std::vector<std::string> iterator2vector(FileManager::bi_iterator ret)
{
    std::vector<std::string> v;
    std::transform(ret.first, ret.second,
		   std::back_inserter(v),
		   __gnu_cxx::select2nd<FileManager::database_type::value_type>());
/*    // equivalent code
    for (FileManager::database_type::const_iterator it = ret.first;
	 it != ret.second; ++it)
    {
	v.push_back(it->second);
	}*/
    return v;
}

std::vector<std::string> FileManager::get_filename(const runnumber_id runnumber) const
{
    FileManager::bi_iterator ret = get_iterator(runnumber);
    return iterator2vector(ret);
}

std::vector<std::string> FileManager::get_filename_all() const
{
    FileManager::bi_iterator ret = get_iterator_all();
    return iterator2vector(ret);
}

std::vector<std::string> FileManager::get_filename_from(const runnumber_id from) const
{
    FileManager::bi_iterator ret = get_iterator_from(from);
    return iterator2vector(ret);
}

std::vector<std::string> FileManager::get_filename_to(const runnumber_id to) const
{
    FileManager::bi_iterator ret = get_iterator_to(to);
    return iterator2vector(ret);
}

std::vector<std::string> FileManager::get_filename_fromto(const runnumber_id from, const runnumber_id to) const
{
    FileManager::bi_iterator ret = get_iterator_fromto(from, to);
    return iterator2vector(ret);
}

// returning TChain*

TChain* iterator2TChain(FileManager::bi_iterator ret)
{
    TChain *chain = new TChain("PAUReco", "PAUReco");
    for (FileManager::database_type::const_iterator it = ret.first;
	 it != ret.second; ++it)
    {
	chain->Add(it->second.c_str());
    }
    return chain;
}


TChain* FileManager::get_chain(runnumber_id runnumber) const
{
    FileManager::bi_iterator ret = get_iterator(runnumber);
    return iterator2TChain(ret);
}

TChain* FileManager::get_chain_all() const
{
    FileManager::bi_iterator ret = get_iterator_all();
    return iterator2TChain(ret);
}

TChain* FileManager::get_chain_from(runnumber_id from) const
{
    FileManager::bi_iterator ret = get_iterator_from(from);
    return iterator2TChain(ret);
}

TChain* FileManager::get_chain_to(runnumber_id to) const
{
    FileManager::bi_iterator ret = get_iterator_to(to);
    return iterator2TChain(ret);
}

TChain* FileManager::get_chain_fromto(runnumber_id from, runnumber_id to) const
{
    FileManager::bi_iterator ret = get_iterator_fromto(from, to);
    return iterator2TChain(ret);
}