// RootHistogramDataset_t.cxx

#include "dataset_root/RootHistogramDataset.h"
#include <iostream>
#include <unistd.h>
#include "dataset_util/FileStatus.h"
#include "dataset_util/XmlElement.h"
#include "dataset_util/FileFinder.h"
#include "dataset_util/getcwd.h"
#include "dataset_util/ssystem.h"
#include "dataset_file/FileManagementSystem.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_credential/CredentialSelectionCatalog.h"
#include "dataset_credential/GssCredentialManager.h"
#include "dataset_base/DatasetCreator.h"
#include "dataset_base/SingleFileDataset.h"
#include "TKey.h"
#include "TH1.h"
#include "TTree.h"

using std::cout;
using std::endl;
using std::string;
using dset::Url;
using dset::FileManagementSystem;
using dset::CredentialSelectionCatalog;
using dset::GssCredentialManager;
using dset::Dataset;
using dset::DatasetCreator;
using dset::GenericDataset;
using dset::SingleFileDataset;
using dset::RootHistogramDataset;

void msg(string txt) {
  cout << "------- ";
  cout << txt;
  cout << " -------" << endl;
}

// return # entries in an object.
int entries(TFile& fil, ContentId cid) {
  string classname = cid.name();
  string fullname = cid.key();
  string path;
  string name = fullname;
  string::size_type ipos = name.rfind('/');
  if ( ipos != string::npos ) {
    path = name.substr(0, ipos);
    name = name.substr(ipos+1);
  }
  bool dstat = fil.cd(path.c_str());
  assert(dstat);
  TKey* pkey = gDirectory->FindKey(name.c_str());
  if ( pkey == 0 ) {
    fil.Print();
    cout << "Fullname: " << fullname << endl;
    cout << "ipos: " << ipos << endl;
    cout << "Path: " << path << endl;
    cout << "      " << fil.GetPath() << endl;
    cout << "Name: " << name << endl;
    cout << "dstat: " << dstat << endl;
  }
  assert( pkey != 0 );
  int count = 0;
  if ( classname.substr(0,2) == "TH" ) {
    TH1* phist = dynamic_cast<TH1*>(pkey->ReadObj());
    assert( phist != 0 );
    count = int(phist->GetEntries());
  } else if ( classname == "TTree" ) {
    TTree* ptree = dynamic_cast<TTree*>(pkey->ReadObj());
    assert( ptree != 0 );
    count = int(ptree->GetEntries());
  } else {
    cout << "Unknown type " << classname << endl;
    assert(false);
  }
  return count;
}

int RootHistogramDataset_t(string fname) {

  cout << "************** Processing " << fname
       << " **************" << endl;

  msg("Clean up");
  system("rm -f dataset.hbk resolver.dat csc.dat");

  msg("Set ID generator");
  SimpleUniqueIdGenerator::create_collection("Dataset", 501, 0);
  SimpleUniqueIdGenerator::set_as_default();

  msg("Fetch default instance of CSC.");
  assert( CredentialSelectionCatalog::create_default_instance() == 0 );
  CredentialSelectionCatalog& sc =
    CredentialSelectionCatalog::default_instance();
  cout << sc << endl;
  assert( sc.is_valid() );
  string owner = "me";
  assert( GssCredentialManager::set_default() == 0 );
  assert( GssCredentialManager::set_owner("me") == 0 );

  msg("Create FMS");
  assert( FileManagementSystem::create_simple_instance() == 0 );
  cout << FileManagementSystem::default_instance() << endl;

  msg("Write job ID");
  unlink("jid");
  Text tjid("jid");
  tjid.append("1234-4321");
  tjid.write();

  msg("Static methods");
  string xname = RootHistogramDataset::xml_name();
  cout << xname << endl;
  assert( xname.size() != 0 );

  msg("Find root file");
  string infile = FileFinder(getcwd(), 5, -1).find(fname);
  cout << infile << endl;
  assert( infile.size() != 0 );
  assert( FileStatus(infile).is_readable() );
  Url inurl("file:" + infile);
  cout << inurl << endl;
  
  msg("Check empty file");
  system("touch empty.root");
  Url eurl("file:" + getcwd() + "/empty.root");
  cout << eurl << endl;
  RootHistogramDataset edst(eurl, "BAD");
  cout << edst << endl;
  assert( edst.is_valid() );

  msg("Create dataset");
  RootHistogramDataset ds(inurl, "TEST");
  cout << ds << endl;
  assert( ds.is_valid() );
  assert( ds.id().is_valid() );
  assert( ds.is_locked() );
  assert( ds.error() == 0 );
  assert( ! ds.is_event_dataset() );
  assert( ds.se_file() == inurl );

  msg("Stage file");
  cout << ds.staged_file() << endl;
  assert( ds.staged_file().is_valid() );
  assert( ds.staged_file() == inurl );

  msg("Check type info");
  assert( ds.is<Dataset>() );
  assert( ds.is<GenericDataset>() );
  assert( ds.is<RootHistogramDataset>() );
  assert( RootHistogramDataset::cast(&ds) == &ds );

  msg("Check root file");
  cout << ds.root_file().GetName() << endl;
  assert( ds.root_file().IsOpen() );
  assert( FileName(ds.root_file().GetName()).fullpath().name()
          == infile );

  msg("Check entry count");
  ContentId cid = *ds.content().front().content_ids().begin();
  cout << "Checking entry " << cid << endl;
  int count0 = entries(ds.root_file(), cid);
  cout << count0 << endl;
  assert( count0 > 0 );

  msg("Clone");
  {
    Dataset* pdsc = ds.clone(getcwd());
    assert( pdsc != 0 );
    assert( ! pdsc->is_locked() );
    assert( pdsc->parent_id() == ds.id() );
    const Dataset& dsc = *pdsc;
    assert( dsc.is_valid() );
    assert( dsc.id().is_valid() );
    assert( ! (dsc.id() == ds.id()) );
    const RootHistogramDataset& hdsc = dsc.cast<RootHistogramDataset>();
    assert( hdsc.error() == 0 );
    msg("Lock the clone");
    int lockstat = pdsc->lock();
    if ( lockstat != 0 ) {
      cout << "Lock failed with error " << lockstat << endl;
    }
    assert( lockstat == 0 );
    assert( dsc.is_locked() );
    cout << dsc << endl;
    assert( hdsc.se_file().is_valid() );

    msg("Check cloned entry count");
    int count1 = entries(ds.root_file(), cid);
    cout << count1 << endl;
    assert( count1 > 0 );
    assert( count1 == count0 );
    delete pdsc;
  }

  msg("Merge");
  string mergefile = "merge_" + fname;
  ssystem("cp " + infile + " " + mergefile);
  Url url_merge("file:" + getcwd() + "/" + mergefile);
  assert( url_merge.is_valid() );
  RootHistogramDataset dsc1(url_merge, "TEST", 0, DatasetId(), false);
  RootHistogramDataset dsc2(inurl, "TEST");
  cout << dsc1 << endl;
  cout << "Stage: " << dsc1.staged_file() << endl;
  assert( dsc1.is_valid() ) ;
  cout << dsc2 << endl;
  assert( dsc2.is_valid() ) ;
  int dcount = entries(dsc1.root_file(), cid);
  int tcount = dcount;
  for ( int itry=1; itry<=5; ++itry ) {
    cout << "...again " << itry << endl;
    cout << dsc1 << endl;
    cout << "Stage: " << dsc1.staged_file() << endl;
    cout << dsc2 << endl;
    int mstat = dsc1.merge(dsc2, getcwd());
    cout << "Return status: " << mstat << endl;
    assert( mstat == 0 );
    cout << dsc1 << endl;
    msg("Check merged entry count");
    tcount += dcount;
    int count2 = entries(dsc1.root_file(), cid);
    cout << count2 << endl;
    assert( count2 > 0 );
    assert( count2 == tcount );
  }
  msg("Lock merged");
  assert( dsc1.lock() == 0 );
  cout << dsc1 << endl;
  cout << "Stage: " << dsc1.staged_file() << endl;

  msg("Merge into clone");
  {
    Dataset* pdsc = ds.clone(getcwd());
    const RootHistogramDataset& hdsc = pdsc->cast<RootHistogramDataset>();
    assert( hdsc.error() == 0 );
    assert( pdsc != 0 );
    int count1 = entries(hdsc.root_file(), cid);
    assert( count1 > 0 );
    int mstat = pdsc->merge(dsc2, getcwd());
    cout << "Return status: " << mstat << endl;
    assert( mstat == 0 );
    cout << *pdsc << endl;
    msg("Check merged entry count");
    int count2 = entries(dsc2.root_file(), cid);
    assert( count2 > 0 );
    int tcount = entries(hdsc.root_file(), cid);
    assert( count2 > 0 );
    cout << count1 << " + " << count2 << " = " << tcount << endl;
    assert( tcount == (count1 + count2) );
  }

  msg("Use single-file creator");
  DatasetId did(123, 456);
  const Dataset* pdst = SingleFileDataset::
    create("RootHistogramDataset", inurl, "JUNK", did);
  assert( pdst != 0 );
  cout << *pdst << endl;
  assert( pdst->is_locked() );
  assert( pdst->location().files().size() == 1 );
  assert( pdst->location().files().front() == inurl );
  assert( pdst->content().size() == 1 );
  assert( pdst->content().front().name() == "JUNK" );
  assert( pdst->parent_id() == did );

  msg("Create XML");
  const XmlElement* pele = ds.xml();
  assert( pele != 0 );
  cout << *pele << endl;

  msg("Reconstruct from XML");
  {
    const Dataset* pds2 = DatasetCreator::create(*pele);
    assert( pds2 != 0 );
    const Dataset& ds2 = *pds2;
    cout << ds2 << endl;
    assert( ds2.is_valid() );
    assert( ds2.id().is_valid() );
    assert( ds2.id() == ds.id() );
    assert( ds2.is_locked() );
    assert( ds2.is<RootHistogramDataset>() );
    const RootHistogramDataset& cds2 = ds2.cast<RootHistogramDataset>();
    assert( cds2.se_file() == inurl );
    assert( cds2.error() == 0 );
    assert( cds2.root_file().IsOpen() );
    delete pds2;
  }

  msg("DTD");
  assert( RootHistogramDataset::dtd().size() != 0 );
  cout << RootHistogramDataset::dtd() << endl;

  return 0;
}

#ifdef CTEST_MAIN
int main() {
  int stat = 0;
  stat = RootHistogramDataset_t("hist.root");
  if ( stat != 0 ) return stat;
  stat = RootHistogramDataset_t("hist2.root");
  if ( stat != 0 ) return stat;
  stat = RootHistogramDataset_t("ntup.root");
  if ( stat != 0 ) return stat;
  return 0;
}
#endif