// Dataset_t.h

#ifndef dial__Dataset_t_H
#define dial__Dataset_t_H

// Defines a Dataset subclass TestDataset for use in testing.
// Also defines a test Dataset ID collection.

#include "dataset_util/ThreadCredential.h"
#include "dataset_util/DtdRegistry.h"
#include "dataset_id/DatasetId.h"
#include "dataset_id/UniqueIdGenerator.h"
#include "dataset_base/Location.h"
#include "dataset_base/Dataset.h"

// Test class for Dataset.

class TestDataset : public virtual dset::Dataset {

private:  // data

  DatasetId m_id;
  DatasetId m_pid;
  const Dataset* m_parent;
  bool m_lock;
  dset::Content m_con;
  dset::Location m_loc;
  Time m_ctime;
  std::string m_own;

public:  // Static methods

  // XML name.
  static const char* xml_name() { return "TestDataset"; }

  // DTD.
  static const Text& dtd() {
    static Text txt;
    if ( txt.size() == 0 ) {
      txt.append("<!ELEMENT TestDataset (Content, Location)>");
      txt.append("<!ATTLIST TestDataset");
      txt.append("  id      CDATA #REQUIRED");
      txt.append("  parent  CDATA #IMPLIED");
      txt.append("  owner   CDATA #IMPLIED");
      txt.append(">");
    }
    return txt;
  }

public:  // Constructors and destructors.

  // Constructor for empty dataset.
  explicit TestDataset(bool valid =true, const Dataset* pparent =0)
  : m_parent(pparent), m_lock(false), m_ctime(time(0)),
     m_own(ThreadCredential().owner()) {
    if ( valid ) {
      m_id = Dataset::id_generator().next();
    }
  }

  // Constructor for virtual dataset.
  explicit TestDataset(const dset::Content& con, const Dataset* pparent =0)
  : m_id(Dataset::id_generator().next()), m_parent(pparent), m_lock(false),
    m_con(con), m_ctime(time(0)), m_own(ThreadCredential().owner()) {
  }

  // Constructor for non-virtual dataset.
  // (If location is not empty)
  TestDataset(const dset::Content& con, const dset::Location& loc,
              const Dataset* pparent =0)
  : m_id(Dataset::id_generator().next()), m_parent(pparent), m_lock(false),
    m_con(con), m_loc(loc), m_ctime(time(0)),
    m_own(ThreadCredential().owner()) {
  }

  // Full constructor for creator.
  TestDataset(DatasetId id, const dset::Dataset* pparent,
              const dset::Content& con, const dset::Location& loc)
  : m_id(id), m_parent(pparent), m_lock(true), m_con(con), m_loc(loc),
    m_ctime(time(0)), m_own(ThreadCredential().owner()) {
    if ( pparent != 0 ) {
      m_pid = pparent->id();
    }
  }

public:  // inherited virtual functions

  // Type.
  std::string fulltype() const { return "TestDataset"; }

  // ID.
  DatasetId id() const { return m_id; }

  // Parent ID.
  DatasetId parent_id() const { 
    if ( m_parent == 0 ) {
      return DatasetId();
    } else {
      return m_parent->id();
    }
  }

  // Parent.
  const Dataset* parent() const { return m_parent; }

  // Owner.
  std::string owner() const { return m_own; }

  // Owner.
  Time create_time() const { return m_ctime; }

  // Clone.
  Dataset* clone(std::string) const {
    if ( ! is_locked() ) return 0;
    return new TestDataset(m_con, m_loc, this);
  }

  // Lock status.
  bool is_locked() const { return m_lock; }

  // Return the content.
  const dset::Content& content() const { return m_con; }

  // Return the location.
  const dset::Location& location() const { return m_loc; }

  // Return if this an event dataset.
  bool is_event_dataset() const {
    return content().size() && content().front().has_events();
  }
  
  // Return the event count.
  EventIdList::size_type event_count() const {
    return event_ids().size();
  }
  
  // Return the list of event_ids.
  const EventIdList& event_ids() const {
    if ( ! is_event_dataset() ) {
      static EventIdList empty;
      return empty;
    }
    return content().front().event_ids();
  }

  // Memory size.
  size_t memsize() const {
    return 99;
  }

  // XML.
  const XmlElement* xml() const {
    if ( ! is_valid() ) return 0;
    if ( ! is_locked() ) return 0;
    XmlElement* pele = new XmlElement("TestDataset");
    pele->add_attribute("id", id().to_string());
    pele->add_attribute("owner", owner());
    if ( parent() != 0 ) {
      pele->add_attribute("parent", parent()->id().to_string());
    }
    pele->add_child(m_con.xml());
    pele->add_child(m_loc.xml());
    return pele;
  }

  // Lock.
  int lock() {
    m_lock = true;
    return 0;
  }

  // Set ID.
  int set_id(const DatasetId& newid) {
    if ( !is_locked() && !id().is_global() ) {
      m_id = newid;
      return 0;
    }
    return 1;
  }

  // Set unique ID.
  int set_id() {
    return 1;
  }

  // Set parent ID.
  int set_parent_id(const DatasetId& newid) {
    if ( !is_locked() && !id().is_global() ) {
      m_pid = newid;
      return 0;
    }
    m_parent = 0;
    return 1;
  }


  // Set parent.
  int set_parent(const Dataset& dst) {
    if ( ! is_valid() ) return 1;
    if ( ! dst.is_valid() ) return 2;
    if ( is_locked() ) return 3;
    if ( ! dst.is_locked() ) return 4;
    if ( ! dst.id().is_valid() ) return 5;
    m_parent = &dst;
    m_pid = dst.id();
    return 0;
  }

  // Set the content.
  int set_content(const dset::Content& con) {
    if ( ! is_valid() ) return 1;
    if ( is_locked() ) return 2;
    m_con = con;
    return 0;
  }

  // Merge.
  int merge(const Dataset&, std::string) {
    return 0;
  }

  // Select.
  int select(const dset::Content&) {
    return 1;
  }

  // Select events.
  int select_events(const EventIdList&) {
    return 1;
  }

};

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

namespace {

// Register the DTD.
DtdRegistry::Status stat_TestDataset_dtd =
  DtdRegistry::register_dtd<TestDataset>("dataset");

}

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

#endif