// DatasetSelectionCatalog.cxx

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

using std::string;
using std::ostream;
using dset::GenericSelectionCatalog;
using dset::ConnectionResolver;
using dset::DatasetSelectionCatalog;

typedef GenericSelectionCatalog::IdList StringIdList;
typedef DatasetSelectionCatalog::size_type size_type;
typedef DatasetSelectionCatalog::Name Name;
typedef DatasetSelectionCatalog::NameList NameList;
typedef DatasetSelectionCatalog::Attributes Attributes;
typedef DatasetSelectionCatalog::IdList IdList;

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

namespace {

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

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

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

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

}  // end unnamed namespace

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

// Return the default instance.

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

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

// Set the default instance.

int DatasetSelectionCatalog::
set_default_instance(DatasetSelectionCatalog* pdsc) {
  defcat(pdsc);
  return 0;
}

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

// Set the default instance.

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

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

// Create default instance.

int DatasetSelectionCatalog::create_default_instance() {
  // Define connection resolver.
  ConnectionResolver::set_configuration_file("resolver.dat");
  // Error if catalog is already present.
  ConnectionResolver res;
  if ( res.resolve("DatasetSelectionCatalog", "").size() ) return 2;
  string conn = "SQLRESULT:" + getcwd() +"/dsc.dat";
  // Append to resolver.
  Text txt("resolver.dat");
  txt.append("DatasetSelectionCatalog");
  txt.append(conn);
  txt.write();
  // Construct file description of repository.
  system("rm -f dsc.dat");
  Text tdsc("dsc.dat");
  tdsc.append("SQLRESULT");
  tdsc.append("uid,name,level,type,virtual,parent,nevt,nfile,nsub" +
       string(",runmin,evtmin,runmax,evtmax,update_uid,owner"));
  tdsc.append("0-0,.TYPE:DatasetSelectionCatalog,,,,,,,,,,,,,");
  tdsc.append("0-0,.ID:uid,,,,,,,,,,,,,");
  tdsc.write();
  // Create catalog.
  return DatasetSelectionCatalog::set_default_instance(conn);
}   

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

// Copy constructor.

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

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

// Assignment.

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

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

// Default Constructor.

DatasetSelectionCatalog::DatasetSelectionCatalog() : m_pcat(0) { }

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

// Constructor from a generic catalog.

DatasetSelectionCatalog::
DatasetSelectionCatalog(GenericSelectionCatalog* pcat)
: m_pcat(pcat) { }

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

// Constructor from connection string.

DatasetSelectionCatalog::DatasetSelectionCatalog(string conn)
: m_pcat(
    GenericSelectionCatalog::create("DatasetSelectionCatalog", conn)
  ) { }
 
//**********************************************************************

// Destructor.

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

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

// Validity.

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

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

// Type.

Name DatasetSelectionCatalog::catalog_type() const {
  return "DatasetSelectionCatalog";
}

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

// ID encoding.

Name DatasetSelectionCatalog::id_encoding() const {
  if ( ! is_valid() ) return "";
  return m_pcat->id_encoding();
}

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

// Schema.

NameList DatasetSelectionCatalog::schema() const {
  if ( ! is_valid() ) return NameList();
  return m_pcat->schema();
}

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

// Does a dataset name appear in the catalog?

bool DatasetSelectionCatalog::has_name(string name) const {
  if ( ! is_valid() ) return false;
  return m_pcat->has_name(name);
}

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

// Retrieve the attributes corresponding to a given name.

Attributes DatasetSelectionCatalog::attributes(Name name) const {
  Attributes atts;
  if ( ! is_valid() ) return atts;
  atts = m_pcat->attributes(name);
  return atts;
}

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

// Return the ID associated with a name.

DatasetId DatasetSelectionCatalog::id(Name name) const {
  if ( ! is_valid() ) return DatasetId();
  DatasetId id(m_pcat->id(name));
  return id;
}

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

// Return the number of entries.

size_type DatasetSelectionCatalog::size() const {
  return query_count(SqlQuery());
}

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

// Return the namess of all datasets satisfying a query.

NameList DatasetSelectionCatalog::
query(SqlQuery qry, size_type maxent) const {
  NameList names;
  if ( ! is_valid() ) return names;
  names = m_pcat->query(qry, maxent);
  return names;
}

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

// Retrieve the number of entries resulting from query.

size_type DatasetSelectionCatalog::query_count(SqlQuery qry) const {
  if ( ! is_valid() ) return 0; 	
  return m_pcat->query_count(qry);	
}

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

// Web page.

Text DatasetSelectionCatalog::
web_page(string baseurl, string entry, string uidurl) const {
  if ( ! is_valid() ) {
    Text wp;
    wp.append(
      "<html>Dataset selection catalog is not defined</html>");
    return wp;
  }
  return m_pcat->web_page(baseurl, entry, uidurl);
}

//**********************************************************************
// Non-const methods.
//**********************************************************************

// Insert a new entry in the catalog.

int DatasetSelectionCatalog::
insert(Name name, const Attributes& atts) {
  if ( ! is_valid() ) return 1; 	
  return m_pcat->insert(name, atts);
}

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

// Update an existing entry in the catalog.

int DatasetSelectionCatalog::
update(Name name, const Attributes& atts) { 
  // Exit if repository is invalid
  if ( ! is_valid() ) return 1;
  return m_pcat->update(name, atts);
}

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

// Remove an entry.

int DatasetSelectionCatalog::remove(Name name) {
  // Exit if repository is invalid
  if ( ! is_valid() ) return 1; 	
  return m_pcat->remove(name);
}

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

// Output stream.

ostream& operator<<(ostream &lhs, const DatasetSelectionCatalog& rhs) {
  if ( ! rhs.is_valid() ) {
    lhs << "Invalid dataset selection catalog";
    return lhs;
  }
  size_type count = rhs.size();
  lhs << "Dataset selection catalog has " << count << " entr";
  if ( count == 1 ) {
    lhs << "y";
  } else {
    lhs << "ies";
  }
  const NameList& cnames = rhs.schema();
  lhs << " and " << cnames.size() << " column";
  if ( cnames.size() != 1 ) lhs << "s";
  return lhs;
}

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