// DatasetFileCatalog.cxx

#include "dataset_file/DatasetFileCatalog.h"
#include <iostream>
#include <sstream>
#include "dataset_util/getcwd.h"
#include "dataset_sql/SqlQuery.h"
#include "dataset_file/FileCatalog.h"
#include "dataset_catalog/ConnectionResolver.h"

using std::string;
using std::ostream;
using std::ostringstream;
using std::istringstream;
using dset::SqlQuery;
using dset::Url;
using dset::FileCatalog;
using dset::ConnectionResolver;
using dset::DatasetSelectionCatalog;
using dset::DatasetFileCatalog;

typedef DatasetFileCatalog::Name Name;
typedef DatasetFileCatalog::NameList NameList;
typedef DatasetFileCatalog::Attributes Attributes;
typedef DatasetFileCatalog::IdList IdList;

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

namespace {

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

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

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

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

}  // end unnamed namespace

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

// Return the default instance.

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

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

// Set the default instance.

int DatasetFileCatalog::
set_default_instance(DatasetFileCatalog* pdfc) {
  defcat(pdfc);
  return 0;
}

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

// Set the default instance.

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

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

// Create default instance.

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

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

// Copy constructor.

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

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

// Assignment.

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

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

// Default Constructor.

DatasetFileCatalog::DatasetFileCatalog() { }

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

// Constructor from a generic catalog.

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

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

// Constructor from connection string.

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

// Destructor.

DatasetFileCatalog::~DatasetFileCatalog() { 
}

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

// Catalog type.

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

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

// Does a logical file appear in the catalog?

bool DatasetFileCatalog::has_file(Url furl) const {
  if ( ! is_valid() ) return false;
  return has_name(furl.to_string());
}

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

// Return the logical file associated with a Dataset ID.

Url DatasetFileCatalog::file(DatasetId id) const {
  if ( ! is_valid() ) return Url();
  if ( ! id.is_valid() ) return Url();
  string sid = id.to_string();
  string qstr;
  if ( id_encoding() == "uid" ) {
    qstr = "uid = '";
    qstr += sid;
    qstr += "'";
  } else {
    return Url();
  }
  SqlQuery qry(qstr);
  NameList names = query(qry,1);
  if ( names.size() == 0 ) return Url();
  Url url(names[0]);
  return url;
}

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

// Return the ID associated with a logical file.

DatasetId DatasetFileCatalog::id_for_file(Url furl) const {
  if ( ! is_valid() ) return DatasetId();
  if ( ! furl.is_valid() ) return DatasetId();
  return id(furl.to_string());
}

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

// Insert a new entry in the catalog.

int DatasetFileCatalog::insert(DatasetId, const Attributes&) {
  return 81;
}

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

// Insert a new entry in the catalog.

int DatasetFileCatalog::
insert_file(DatasetId id, Url furl, const Attributes& atts) {
  if ( ! is_valid() ) return 41; 	
  Attributes newatts = atts;
  if ( id_encoding() == "uid" ) {
    newatts["uid"] = id.to_string();
  }
  Name name = furl.to_string();
  int stat = DatasetSelectionCatalog::insert(name, newatts);
  return stat;
}

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

// Update an existing entry in the catalog.

int DatasetFileCatalog::
update(Name name, const Attributes& atts) { 
  // Exit if repository is invalid
  if ( ! is_valid() ) return 41;
  // Update.
  return DatasetSelectionCatalog::update(name, atts);
}

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

// Output stream.

ostream& operator<<(ostream &lhs, const DatasetFileCatalog& rhs) {
  if ( ! rhs.is_valid() ) {
    lhs << "Invalid dataset file catalog";
    return lhs;
  }
  DatasetFileCatalog::size_type count = rhs.size();
  lhs << "Dataset file 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;
}

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