// DatasetReplicaCatalog.cxx

#include "dataset_catalog/DatasetReplicaCatalog.h"
#include <iostream>
#include "dataset_util/getcwd.h"
#include "dataset_catalog/ConnectionResolver.h"

using std::string;
using std::ostream;
using dset::GenericReplicaCatalog;
using dset::ConnectionResolver;
using dset::DatasetReplicaCatalog;

typedef GenericReplicaCatalog::Id GenericId;
typedef GenericReplicaCatalog::IdList GenericIdList;
typedef DatasetReplicaCatalog::size_type size_type;
typedef DatasetReplicaCatalog::size_type size_type;
typedef DatasetReplicaCatalog::Id Id;
typedef DatasetReplicaCatalog::IdList IdList;
typedef DatasetReplicaCatalog::Status Status;

//**********************************************************************
// Local definitions.
//**********************************************************************

namespace {

//**********************************************************************

// Convert GenericIdList to Idlist.

void from_generic(const GenericIdList& gids, IdList& ids) {
  for ( GenericIdList::const_iterator igid=gids.begin();
        igid!=gids.end(); ++igid ) {
    Id id(*igid);
    ids.insert(id);
  }
}

//**********************************************************************

// Convert Id list to GenericIdList.

void to_generic(const IdList& gids, GenericIdList& ids) {
  for ( IdList::const_iterator iid=gids.begin();
        iid!=gids.end(); ++iid ) {
    GenericId gid = iid->to_string();
    ids.push_back(gid);
  }
}

//**********************************************************************

// Default catalog.
// First pass, use set_default_instance or define an invalid catalog if
// this fails.

DatasetReplicaCatalog* defcat(DatasetReplicaCatalog* pnewcat =0) {
  static bool first = true;
  static DatasetReplicaCatalog* pcat = 0;
  if ( first ) {
    first = false;
    DatasetReplicaCatalog::set_default_instance("");
    if ( pcat == 0 ) {
      pcat = new DatasetReplicaCatalog;
    }
  }
  if ( pnewcat != 0 ) {
    delete pcat;
    pcat = pnewcat;
  }
  return pcat;
}

//**********************************************************************

}  // end unnamed namespace

//**********************************************************************
// Static methods.
//**********************************************************************

// Return the default instance.

DatasetReplicaCatalog& DatasetReplicaCatalog::default_instance() {
  return *defcat();
}

//**********************************************************************

// Set the default instance.

int DatasetReplicaCatalog::
set_default_instance(DatasetReplicaCatalog* pdrc) {
  defcat(pdrc);
  return 0;
}

//**********************************************************************

// Set the default instance.

int DatasetReplicaCatalog::set_default_instance(string name) {
  DatasetReplicaCatalog* pcat = new DatasetReplicaCatalog(name);
  if ( pcat->is_valid() ) {
    defcat(pcat);
  } else {
    delete pcat;
    return 1;
  }
  return 0;
}

//**********************************************************************

// Create default instance.

int DatasetReplicaCatalog::create_default_instance() {
  // Define connection resolver.
  ConnectionResolver::set_configuration_file("resolver.dat");
  // Error if catalog is already present.
  ConnectionResolver res;
  if ( res.resolve("DatasetReplicaCatalog", "").size() ) return 2;
  string conn = "SQLRESULT:" + getcwd() + "/drc.dat";
  // Append to resolver.
  Text txt("resolver.dat");
  txt.append("DatasetReplicaCatalog");
  txt.append(conn);
  txt.write();
  // Construct file description of repository.
  system("rm -f drc.dat");
  Text tdrc("drc.dat");
  tdrc.append("SQLRESULT");
  tdrc.append("lid,rid");
  tdrc.append("0-0,DatasetReplicaCatalog");
  tdrc.write();
  // Create catalog.
  return DatasetReplicaCatalog::set_default_instance(conn);
}   

//**********************************************************************
// Private methods.
//**********************************************************************

// Copy constructor.

DatasetReplicaCatalog::
DatasetReplicaCatalog(const DatasetReplicaCatalog&) { 
  assert(false);
}

//**********************************************************************

// Assignment.

DatasetReplicaCatalog& DatasetReplicaCatalog::
operator=(const DatasetReplicaCatalog&) { 
  assert(false);
  return *this;
}

//**********************************************************************
// Constructors and destructor.
//**********************************************************************

// Default Constructor.

DatasetReplicaCatalog::DatasetReplicaCatalog() : m_pcat(0) { }

//**********************************************************************

// Constructor from a generic catalog.

DatasetReplicaCatalog::
DatasetReplicaCatalog(GenericReplicaCatalog* pcat)
: m_pcat(pcat) { }

//**********************************************************************

// Constructor from connection string.

DatasetReplicaCatalog::DatasetReplicaCatalog(string conn)
: m_pcat(
    GenericReplicaCatalog::create("DatasetReplicaCatalog", conn)
  ) { }
 
//**********************************************************************

// Destructor.

DatasetReplicaCatalog::~DatasetReplicaCatalog() { 
  delete m_pcat;	
}

//**********************************************************************
// Const methods.
//**********************************************************************

// Validity.

bool DatasetReplicaCatalog::is_valid() const {
  return m_pcat != 0 && m_pcat->is_valid() &&
         m_pcat->catalog_type() == "DatasetReplicaCatalog";
}

//**********************************************************************

// Number of logicals.

size_type DatasetReplicaCatalog::logical_size() const {
  if ( ! is_valid() ) return 0;
  return m_pcat->logical_size();
}

//**********************************************************************

// Number of replicas.

size_type DatasetReplicaCatalog::replica_size() const {
  if ( ! is_valid() ) return 0;
  return m_pcat->replica_size();
}

//**********************************************************************

// Has a logical.

bool DatasetReplicaCatalog::has_logical(Id lid) const {
  if ( ! is_valid() ) return false;
  if ( ! lid.is_valid() ) return false;
  return m_pcat->has_logical(lid.to_string());
}

//**********************************************************************

// Has a replica.

bool DatasetReplicaCatalog::has_replica(Id rid) const {
  if ( ! is_valid() ) return false;
  if ( ! rid.is_valid() ) return false;
  return m_pcat->has_replica(rid.to_string());
}

//**********************************************************************

// Has a logical-replica mapping.

bool DatasetReplicaCatalog::has(Id lid, Id rid) const {
  if ( ! is_valid() ) return false;
  if ( ! lid.is_valid() ) return false;
  if ( ! rid.is_valid() ) return false;
  return m_pcat->has(lid.to_string(), rid.to_string());
}

//**********************************************************************

// Return the list of logicals.

IdList DatasetReplicaCatalog::logicals() const {
  IdList ids;
  if ( ! is_valid() ) return ids;
  GenericIdList gids = m_pcat->logicals();
  from_generic(gids, ids);
  return ids;
}

//**********************************************************************

// Return the list of replicas.

IdList DatasetReplicaCatalog::replicas() const {
  IdList ids;
  if ( ! is_valid() ) return ids;
  GenericIdList gids = m_pcat->replicas();
  from_generic(gids, ids);
  return ids;
}

//**********************************************************************

// Return the list of replicas associated with a logical.

IdList DatasetReplicaCatalog::replicas(Id lid) const {
  IdList ids;
  if ( ! is_valid() ) return ids;
  if ( ! lid.is_valid() ) return ids;
  GenericIdList gids = m_pcat->replicas(lid.to_string());
  from_generic(gids, ids);
  return ids;
}

//**********************************************************************

// Return the logical associated with a replica.

Id DatasetReplicaCatalog::logical(Id rid) const {
  Id id;
  if ( ! is_valid() ) return id;
  if ( ! rid.is_valid() ) return id;
  GenericId gid = m_pcat->logical(rid.to_string());
  return Id(gid);
}

//**********************************************************************
// Non-const members.
//**********************************************************************

// Insert replicas.

Status DatasetReplicaCatalog::insert(Id lid, const IdList& rids) {
  if ( ! is_valid() ) return 1; 
  if ( ! lid.is_valid() ) return 2; 
  GenericIdList gids;
  to_generic(rids, gids);
  return m_pcat->insert(lid.to_string(), gids);
}

//**********************************************************************

// Update replicas.

Status DatasetReplicaCatalog::update(Id lid, const IdList& rids) {
  if ( ! is_valid() ) return 1; 
  if ( ! lid.is_valid() ) return 2; 
  GenericIdList gids;
  to_generic(rids, gids);
  return m_pcat->update(lid.to_string(), gids);
}

//**********************************************************************

// Remove a replica.

Status DatasetReplicaCatalog::remove_replica(Id lid, Id rid) {
  if ( ! is_valid() ) return 1; 
  if ( ! lid.is_valid() ) return 2; 
  if ( ! rid.is_valid() ) return 3; 
  return m_pcat->remove_replica(lid.to_string(), rid.to_string());
}

//**********************************************************************

// Remove a logical.

Status DatasetReplicaCatalog::remove_logical(Id lid) {
  if ( ! is_valid() ) return 1; 
  if ( ! lid.is_valid() ) return 2; 
  return m_pcat->remove_logical(lid.to_string());
}

//**********************************************************************
// Free functions.
//**********************************************************************

// Output stream.

ostream& operator<<(ostream &lhs, const DatasetReplicaCatalog& rhs) {
  if ( ! rhs.is_valid() ) {
    lhs << "Invalid dataset replica catalog";
    return lhs;
  }
  size_type lcount = rhs.logical_size();
  size_type rcount = rhs.replica_size();
  lhs << "Dataset replica catalog has " << lcount << " logical";
  if ( lcount != 1 ) {
    lhs << "s";
  }
  lhs << " and " << rcount << " replica";
  if ( rcount != 1 ) {
    lhs << "s";
  }
  return lhs;
}

//**********************************************************************