// SimpleUniqueIdGenerator_t.cxx

#include "dataset_id/SimpleUniqueIdGenerator.h"
#include <string>
#include <iostream>
#include <cassert>
#include <utility>
#include <fstream>
#include "dataset_util/FileName.h"

using std::string;
using std::cout;
using std::endl;
#if ( __GNUC__ != 2 )
  using namespace std::rel_ops;
#endif
using std::ofstream;

void msg(const char* msg) {
  cout << "----- ";
  cout << msg;
  cout << " -----" << endl;
}

int SimpleUniqueIdGenerator_t() {

  bool verbose = 0;
  msg("Set base generator");
  string conn = "SimpleUniqueIdGenerator:./UniqueId:3:";
  if ( verbose ) conn += "true";
  else conn += "false";
  cout << conn << endl;
  int gstat = UniqueIdGenerator::set_generator(conn);
  if ( gstat != 0 ) {
    cout << "Error " << gstat << endl;
    return 1;
  }
  assert( UniqueIdGenerator::connection() == conn );

  // Create test generators.
  msg("Create collection files");
  string com = "rm -rf UniqueId";
  system(com.c_str());
  {
    int istat0 =
      SimpleUniqueIdGenerator::create_collection("UIGTEST1", 1000, 123);
    cout << istat0 << endl;
    assert( istat0 != 0 );
    int istat1 = 
      SimpleUniqueIdGenerator::create_collection("UIGTEST1", 901, 123);
    cout << istat1 << endl;
    assert( istat1 == 0 );
    int istat2 = 
      SimpleUniqueIdGenerator::create_collection("UIGTEST2", 902, 800);
    cout << istat2 << endl;
    assert( istat2 == 0 );
  }

  SimpleUniqueIdGenerator* pgen1;
  msg("Create generator");
  {
    SimpleUniqueIdGenerator* pgen =
      SimpleUniqueIdGenerator::find_generator("UIGTEST1", verbose);
    assert( pgen != 0 );
    cout << *pgen << endl;
    assert( pgen->is_valid() );
    assert( pgen->is_open() );
    assert( pgen->context() == "UIGTEST1");
    assert( pgen->collection() == 901L );
    assert( pgen->size_assigned() == 123 );
    pgen1 = pgen;
  }

  msg("Create a generator using base class");
  {
    UniqueIdGenerator* pgen0 =
      UniqueIdGenerator::find_generator("UIGTEST2");
    assert( pgen0 != 0 );
    SimpleUniqueIdGenerator* pgen =
      dynamic_cast<SimpleUniqueIdGenerator*>(pgen0);
    assert( pgen != 0 );
    cout << *pgen << endl;
    assert( pgen->is_valid() );
    assert( pgen->is_open() );
    assert( pgen->context() == "UIGTEST2");
    assert( pgen->collection() == 902L );
    assert( pgen->size_assigned() == 800 );
  }

  msg("Fail to create another generator");
  {
    SimpleUniqueIdGenerator* pgen =
      SimpleUniqueIdGenerator::find_generator("UIGTEST1", verbose);
    assert( pgen == 0 );
  }

  msg("Generate some ID's");
  UniqueId id0 = pgen1->next();
  cout << id0 << endl;
  assert( id0.is_valid() );
  for ( int count=0; count<20; ++count ) {
    UniqueId id = pgen1->next();
    cout << id << endl;
    assert( id.is_valid() );
    assert( id.collection() == pgen1->collection() );
    assert( id > id0 );
    id = id0;
  }

  msg("Close generator");
  string com1 = "ls UniqueId/UIGTEST1/0000000901";
  string com2 = "ls UniqueId/UIGTEST1/0000000901.*";
  assert( pgen1->is_open() );
  assert( system(com1.c_str()) != 0 );
  assert( system(com2.c_str()) == 0 );
  pgen1->close();
  cout << *pgen1 << endl;
  assert( ! pgen1->is_open() );
  assert( system(com1.c_str()) == 0 );
  assert( system(com2.c_str()) != 0 );

  msg("Generate invalid ID");
  UniqueId id = pgen1->next();
  cout << id0 << endl;
  assert( ! id.is_valid() );

  msg("Local generator");
  {
    SimpleUniqueIdGenerator lgen;
    assert( lgen.is_valid() );
    assert( lgen.is_open() );
    UniqueId id0 = lgen.next();
    cout << id0 << endl;
    assert( id0.is_valid() );
    assert( id0.collection() == 0 );
    for ( int count=0; count<20; ++count ) {
      UniqueId id = lgen.next();
      cout << id << endl;
      assert( id.is_valid() );
      assert( id.collection() == 0 );
      assert( id > id0 );
      id = id0;
    }
    lgen.close();
    assert( lgen.is_valid() );
    assert( ! lgen.is_open() );
  }

  msg("Check the base directory");
  cout << SimpleUniqueIdGenerator::base_directory() << endl;
  assert( SimpleUniqueIdGenerator::base_directory().size() > 0 );
  string newdir = "abc";
  string fulldir = FileName(newdir).fullpath().name();
  assert( SimpleUniqueIdGenerator::base_directory("abc") == fulldir );
  cout << SimpleUniqueIdGenerator::base_directory() << endl;

  return 0;
}

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