// SimpleEventDatasetSplitter_t.cxx

#include "dataset_split/SimpleEventDatasetSplitter.h"
#include <string>
#include <iostream>
#include "dataset_util/Environment.h"
#include "dataset_util/XmlElement.h"
#include "dataset_util/DtdRegistry.h"
#include "dataset_id/EventIdList.h"
#include "dataset_id/ContentIdList.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_catalog/DatasetReplicaCatalog.h"
#include "dataset_base/DatasetRepository.h"
#include "dataset_base/Dataset_t.h"
#include "dataset_base/EventMergeDataset.h"

using std::string;
using std::cout;
using std::endl;
using dset::Content;
using dset::Location;
using dset::Url;
using dset::Dataset;
using dset::DatasetList;
using dset::DatasetRepository;
using dset::EventMergeDataset;
using dset::DatasetReplicaCatalog;
using dset::DatasetSplitter;
using dset::SimpleEventDatasetSplitter;

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

bool check(int value, int expect =0) {
  if ( value != expect ) {
    cout << "Expected " << expect << "; found " << value << endl;
  }
  return value == expect;
}

int SimpleEventDatasetSplitter_t() {

  system("rm -rf UniqueId");
  SimpleUniqueIdGenerator::create_collection("Dataset", 123, 1001);
  SimpleUniqueIdGenerator::set_as_default();

  msg("Create test DR and DSC");
  system("rm resolver.dat");
  assert( DatasetRepository::create_default_instance() == 0 );
  assert( DatasetReplicaCatalog::create_default_instance() == 0 );

  msg("Create content");
  string cname = "TestContent";
  ContentId cid = ContentId::register_id(221, cname.c_str());
  ContentId cid1(cname, "first");
  ContentId cid2(cname, "second");
  cout << cid1 << endl;
  cout << cid2 << endl;

  msg("Create content list");
  ContentIdList cids;
  cids.insert(ContentId(cid1));
  cids.insert(ContentId(cid2));
  cout << cids << endl;

  msg("Create event dataset 1");
  EventIdList eids1;
  eids1.insert(EventIdRange(123,1,3));
  Location loc1;
  loc1.files().push_back(Url("file:data1.dat"));
  assert( loc1.is_valid() );
  assert( ! loc1.is_empty() );
  Content con1("TestDataset", "test_content", cids, eids1);
  TestDataset dst1(con1, loc1);
  dst1.lock();
  assert( ! dst1.is_virtual() );
  cout << dst1 << endl;

  msg("Create event dataset 2");
  EventIdList eids2;
  eids2.insert(EventIdRange(123,4,6));
  Location loc2;
  loc2.files().push_back(Url("file:data2.dat"));
  assert( loc2.is_valid() );
  assert( ! loc2.is_empty() );
  Content con2("TestDataset", "test_content", cids, eids2);
  TestDataset dst2(con2, loc2);
  dst2.lock();
  cout << dst2 << endl;

  msg("Create event dataset 3");
  EventIdList eids3;
  eids3.insert(EventIdRange(123,7,10));
  Location loc3;
  loc3.files().push_back(Url("file:data3.dat"));
  assert( loc3.is_valid() );
  assert( ! loc3.is_empty() );
  Content con3("TestDataset", "test_content", cids, eids3);
  TestDataset dst3(con3, loc3);
  dst3.lock();
  cout << dst3 << endl;

  msg("Create splitter");
  SimpleEventDatasetSplitter splitter;
  cout << splitter << endl;

  msg("Split an event dataset");
  DatasetList sdsts = splitter.split(dst1);
  cout << sdsts << endl;
  assert( sdsts.size() == 1 );
  assert( sdsts.front() == &dst1 );

  msg("Create merged dataset");
  bool virt = dst1.is_virtual();
  EventIdList eids0;
  Content con0("TestDataset", "test_content", cids, eids0);
  EventMergeDataset mdst(virt, con0);
  assert( check(mdst.merge(dst1)) );
  assert( check(mdst.merge(dst2)) );
  assert( check(mdst.merge(dst3)) );
  mdst.lock();
  cout << mdst << endl;
  assert( check(mdst.constituents().size(), 3) );

  msg("Split a merged dataset");
  sdsts = splitter.split(mdst);
  cout << sdsts << endl;
  assert( sdsts.size() == 3 );
  assert( sdsts == mdst.constituents() );

  msg("Split and append");
  assert( splitter.split_and_append(mdst, sdsts) == 3 );
  cout << sdsts << endl;
  assert( sdsts.size() == 6 );

  msg("Write to XML");
  const XmlElement* pele = splitter.xml();
  assert( pele != 0 );
  cout << *pele << endl;

  msg("Read XML");
  {
    const DatasetSplitter* psplit = DatasetSplitter::create(*pele);
    assert( psplit != 0 );
    assert( dynamic_cast<const SimpleEventDatasetSplitter*>(psplit) != 0 );
  }

  msg("DTD");
  Text dtd = SimpleEventDatasetSplitter::dtd();
  cout << dtd << endl;
  assert( dtd.size() > 0 );
  assert( DtdRegistry::instance("dataset").
            has_type("SimpleEventDatasetSplitter") );

  msg("Display DTD.");
  DtdRegistry::display(cout) << endl;

  msg("Testing complete");
  return 0;
}

#ifdef CTEST_MAIN
int main() {
  return SimpleEventDatasetSplitter_t();
}
#endif