// SqlGenericRepository_t.cxx

#include "dataset_catalog/SqlGenericRepository.h"
#include <iostream>
#include <sstream>
#include "dataset_util/Text.h"
#include "dataset_util/ThreadCredential.h"
#include "dataset_sql/SqlResultTable.h"
#include "dataset_sql/SqlResult.h"
#include "dataset_catalog/ConnectionResolver.h"
#include "dataset_catalog/CacheGenericRepository.h"

using std::string;
using std::cout;
using std::endl;
using std::ostringstream;
using dset::SqlResult;
using dset::SqlResultTable;
using dset::GenericRepository;
using dset::ConnectionResolver;
using dset::CacheGenericRepository;
using dset::SqlGenericRepository;

typedef SqlResult::Row Row;
typedef SqlGenericRepository::size_type size_type;
typedef SqlGenericRepository::NameList NameList;

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

Row idrow(string type, int idh, int idl, string sxml) {
  ostringstream strh, strl;
  strh << idh;
  strl << idl;
  string sidh = strh.str();
  string sidl = strl.str();
  Row row;
  if ( type == "uid" ) {
    row["uid"] = sidh + "-" + sidl;
  } else if ( type == "idhi" ) {
    row["idhi"] = sidh;
    row["idlo"] = sidl;
  } else if ( type == "vidh" ) {
    row["vidh"] = sidh;
    row["vidl"] = sidl;
  } else {
    assert(false);
  }
  row["sxml"] = sxml;
  return row;
}

int SqlGenericRepository_t(string type) {

  msg("***** Begin testing SqlGenericRepository for type " +
      type + " *****");

  msg("Create starting result");
  NameList cols;
  if ( type == "uid" ) {
    cols.push_back("uid");
  } else if ( type == "idhi" ) {
    cols.push_back("idhi");
    cols.push_back("idlo");
  } else if ( type == "vidh" ) {
    cols.push_back("vidh");
    cols.push_back("vidl");
  } else {
    assert(false);
  }
  cols.push_back("sxml");
  SqlResult res(cols);
  
  msg("Insert type row");
  Row row0 = idrow(type, 0, 0, "SomekindaRepository");
  res.insert_row(row0);
  assert( res.num_rows() == 1 );

  msg("Insert a row");
  Row row1 = idrow(type, 400, 1, "first element");
  res.insert_row(row1);
  assert( res.num_rows() == 2 );
  
  msg("Insert another row");
  Row row2 = idrow(type, 400, 2, "vinay");
  assert( res.insert_row(row2) == 0 );
  assert( res.num_rows() == 3 );

  SqlResultTable sqltable(res);
  SqlGenericRepository rep(sqltable);

  msg("Testing validity");
  assert( rep.is_valid() );

  msg("Testing catalog type");
  assert( rep.repository_type() == "SomekindaRepository" );

  msg("Set thread ownership to gain write access");
  string owner = "me";
  ThreadCredential().set_default_owner(owner);
  cout << ThreadCredential() << endl;

  msg("Insert a new element into repository");
  assert( ThreadCredential().owner() == owner );
  if ( rep.insert("30-30", "third owner=\"" + owner + "\"") != 0 ) { 
    cout << "Insert operation returned error:" << rep.error() << endl;
    cout << rep.error_string(rep.error()) << endl;
    assert(false);
  }  
  
  msg("Testing valid element after insertion");
  if ( ! rep.has("30-30") ) {
    cout << "Query returned error:" << rep.error() << endl;
    cout << rep.error_string(rep.error()) << endl;
    assert(false);
  }
  
  msg("Retrieve a valid element");
  string ele = rep.get("30-30");
  if ( ele.empty() ) {
    cout << "Query returned error:" << rep.error() << endl;
    cout << rep.error_string(rep.error()) << endl;
    assert(false);
  } 
  cout << ele << endl;

  msg("Retrieve multiple elements");
  GenericRepository::ElementList someeles;
  GenericRepository::IdList someids;
  someids.push_back("400-1");
  assert( rep.mget(someids, someeles) == 0 );
  assert( someeles.size() == someids.size() );
  assert( someeles.front() == "first element" );
 
  msg("Retrieve all ids");
  GenericRepository::IdList ids = rep.get_ids(3);
  assert( ids.size() );
  for ( GenericRepository::IdList::const_iterator iid = ids.begin();
        iid!=ids.end(); ++iid ) {
    cout << *iid << endl;
  }
  assert( ids.size() == 3 );
 
  msg("Check size");
  size_type count = rep.size();
  cout << "Size is " << count << endl;
  assert( count == 3 );

  msg("Remove a valid element");
  int rstat = rep.remove("30-30");
  if ( rstat != 0 ) {
    cout << "Delete operation returned error " << rstat << endl;
    cout << rep.error_string(rep.error()) << endl;
    assert(false);
  }
  count = rep.size();
  cout << "Size is " << count << endl;
  assert( count == 2 );
  
  msg("Define catalog resolver");
  system("rm -f resolver.dat");
  Text txt("resolver.dat");
  txt.append("JunkRepository");
  txt.append("SQLRESULT:jr.dat");
  txt.append("SQLRESULT:jrp.dat");
  txt.append("SQLRESULT:jrc.dat");
  txt.write();
  ConnectionResolver::set_configuration_file("resolver.dat");
    
  msg("Construct file description of DR");  
  system("rm -f jr.dat");
  Text tdsc("jr.dat");
  tdsc.append("SQLRESULT");
  tdsc.append("idhi,idlo,sxml");
  tdsc.append("0,0,JunkRepository");
  tdsc.write();

  msg("Check creator");
  string reptype = "JunkRepository";
  string conn = "SQLRESULT";
  GenericRepository* prep = GenericRepository::create(reptype, conn);
  assert( prep != 0 );

  msg("All tests passed successfully");
  return 0;
}

// Test for cache.
int SqlGenericRepository_t_cache() {
  msg(
    "*** Begin SqlGenericRepository test of CacheGenericRepository ***"
  );  
  msg("Construct file description of primary");  
  system("rm -f jrp.dat");
  Text tjrp("jrp.dat");
  tjrp.append("SQLRESULT");
  tjrp.append("idhi,idlo,sxml");
  tjrp.append("0,0,JunkRepository");
  string sone = "<one owner=\"me\">";
  string stwo = "<two owner=\"me\">";
  string sthree = "<three owner=\"me\">";
  string sfour = "<four owner=\"me\">";
  string sfive = "<five owner=\"me\">";
  tjrp.append("1,1," + sone);
  tjrp.append("1,3," + sthree);
  tjrp.append("1,4," + sfour);
  tjrp.write();
  msg("Construct file description of cache");  
  system("rm -f jrc.dat");
  Text tjrc("jrc.dat");
  tjrc.append("SQLRESULT");
  tjrc.append("idhi,idlo,sxml");
  tjrc.append("0,0,JunkRepository SQLRESULT:jrp.dat");
  tjrc.append("1,1," + sone);
  tjrc.append("1,2," + stwo);
  tjrc.write();
  msg("Construct cache");
  string reptype = "JunkRepository";
  string conn = "SQLRESULT:jrc.dat";
  GenericRepository* prep = GenericRepository::create(reptype, conn);
  assert( prep != 0 );
  assert( prep->is_valid() );
  assert( prep->repository_type() == reptype );
  assert( prep->cache_connection() == "" );
  CacheGenericRepository* pcache =
    dynamic_cast<CacheGenericRepository*>(prep);
  assert( pcache != 0 );
  cout << "Primary size is " << prep->size() << endl;
  cout << "Cache size is " << pcache->cache_size() << endl;
  assert( prep->size() == 3 );
  assert( pcache->cache_size() == 2 );
  msg("Fetch from cache");
  assert( prep->get("1-2") == stwo );
  msg("Fetch from primary");
  assert( prep->get("1-3") == sthree );
  cout << "Primary size is " << prep->size() << endl;
  cout << "Cache size is " << pcache->cache_size() << endl;
  assert( prep->size() == 3 );
  assert( pcache->cache_size() == 3 );
  msg("Insert");
  assert( prep->get("1-5") == "" );
  assert( prep->insert("1-5", sfive ) == 0 );
  cout << "Primary size is " << prep->size() << endl;
  cout << "Cache size is " << pcache->cache_size() << endl;
  assert( prep->size() == 4 );
  assert( pcache->cache_size() == 4 );
  assert( prep->get("1-5") == sfive );
  return 0;
} 

#ifdef CTEST_MAIN
int main() {
  int stat = SqlGenericRepository_t("uid");
  if ( stat != 0 ) return stat;
  stat = SqlGenericRepository_t("idhi");
  if ( stat != 0 ) return stat;
  stat = SqlGenericRepository_t("vidh");
  if ( stat != 0 ) return stat;
  return SqlGenericRepository_t_cache();
}
#endif