// ApplicationSelectionCatalog.cxx

#include "dial_app/ApplicationSelectionCatalog.h"
#include <string>
#include <iostream>
#include "dataset_catalog/ConnectionResolver.h"

using std::string;
using std::ostream;
using dset::SqlQuery;
using dset::GenericSelectionCatalog;
using dset::ConnectionResolver;
using dial::ApplicationId;
using dial::ApplicationSelectionCatalog;

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

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

namespace {

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

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

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

}  // end unnamed namespace

//**********************************************************************
// Static members.
//**********************************************************************

// Return the default instance.

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

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

// Set the default instance.

int ApplicationSelectionCatalog::
set_default_instance(ApplicationSelectionCatalog* pasc) {
  defcat(pasc);
  return 0;
}

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

// Set the default instance.

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

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

// Create default instance.

int ApplicationSelectionCatalog::create_default_instance() {
  // Define connection resolver.
  ConnectionResolver::set_configuration_file("resolver.dat");
  // Error if catalog is already present.
  ConnectionResolver res;
  if ( res.resolve("ApplicationSelectionCatalog", "").size() ) return 2;
  string conn = "SQLRESULT:asc.dat";
  // Append to resolver.
  Text txt("resolver.dat");
  txt.append("ApplicationSelectionCatalog");
  txt.append(conn);
  txt.write();
  // Construct file description of repository.
  system("rm -f asc.dat");
  Text tdsc("asc.dat");
  tdsc.append("SQLRESULT");
  tdsc.append("uid,name,owner");
  tdsc.append("0-0,.TYPE:ApplicationSelectionCatalog,");
  tdsc.append("0-0,.ID:uid,");
  tdsc.write();
  // Create catalog.
  return ApplicationSelectionCatalog::set_default_instance(conn);
}   

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

// Copy constructor.

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

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

// Assignment.

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

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

// Default Constructor.

ApplicationSelectionCatalog::ApplicationSelectionCatalog() 
: m_pcat(0) { }

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

// Constructor from a generic selection catalog.

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

//**********************************************************************
                                                                                
// Constructor from connection string.
                                                                                
ApplicationSelectionCatalog::ApplicationSelectionCatalog(string conn) 
: m_pcat(
    GenericSelectionCatalog::create("ApplicationSelectionCatalog", conn)
  ) { }
 
//**********************************************************************

// Destructor.

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

//**********************************************************************
// Const member functions.
//**********************************************************************

// Validity.

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

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

// ID encoding.
  
Name ApplicationSelectionCatalog::id_encoding() const {
  if ( ! is_valid() ) return "";
  return m_pcat->id_encoding();
}

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

// Schema.

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

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

// Does a name appear in the catalog?

bool ApplicationSelectionCatalog::has_name(string name) const {
  // Exit if repository is invalid
  if ( ! is_valid() ) return false;
  return m_pcat->has_name(name);
}

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

// Retrieve the attributes corresponding to a given name.

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

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

// Return the ID associated with a name.

ApplicationId ApplicationSelectionCatalog::id(string name) const {
  if ( ! is_valid() ) return ApplicationId();
  ApplicationId id(m_pcat->id(name));
  return id;
}

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

// Return the number of entries.

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

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

// Return the names of all applications satisfying a query.

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

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

// Retrieve the number of entries resulting from query.

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

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

// Web page.

Text ApplicationSelectionCatalog::
web_page(string baseurl, string entry, string uidurl) const {
  if ( ! is_valid() ) {
    Text wp;
    wp.append(
      "<html>Application 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 ApplicationSelectionCatalog::
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 ApplicationSelectionCatalog::
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 ApplicationSelectionCatalog::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 ApplicationSelectionCatalog& rhs) {
  if ( ! rhs.is_valid() ) {
    lhs << "Invalid application selection catalog";
    return lhs;
  }
  size_type count = rhs.size();
  lhs << "Application selection catalog has " << count << " entr";
  if ( count == 1 ) {
    lhs << "y";
  } else {
    lhs << "ies";
  }
  NameList cnames = rhs.schema();
  lhs << " and " << cnames.size() << " column";
  if ( cnames.size() != 1 ) lhs << "s";
  return lhs;
}

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