// Content_t.cxx

#include "dataset_base/Content.h"
#include <iostream>
#include "dataset_util/Text.h"
#include "dataset_util/XmlElement.h"

using std::cout;
using std::endl;
using dset::ContentBlock;
using dset::Content;

void msg(const char* msg) {
  cout << "----- ";
  cout << msg;
  cout << " -----" << endl;
}

int Content_t() {

  msg("Invalid content");
  Content badcon(123);
  cout << badcon << endl;
  assert( ! badcon.is_valid() );
  assert( badcon.error() == 123 );
  assert( ! badcon.is_empty() );

  msg("Create empty content");
  Content con0;
  cout << con0 << endl;
  assert( con0.is_empty() );
  assert( ! con0.has_event_content() );
  assert( ! con0.has_nonevent_content() );

  msg("Create block without events");
  ContentIdList cids;
  cids.insert(ContentId("Test1", "key1"));
  cids.insert(ContentId("Test2", "key2"));
  cids.insert(ContentId("Test3", "key3"));
  ContentBlock cb1("NoEventDataset", "no-events", cids);
  cout << cb1 << endl;
  assert( cb1.dataset_type() == "NoEventDataset" );
  assert( cb1.name() == "no-events" );
  assert( cb1.content_ids() == cids );
  assert( ! cb1.has_events() );

  msg("Create block with events");
  EventIdList eids;
  eids.insert(EventIdRange(1001, 9500, 9599));
  ContentBlock cb2("EventDataset", "events", cids, eids);
  cout << cb2 << endl;
  assert( cb2.dataset_type() == "EventDataset" );
  assert( cb2.name() == "events" );
  assert( cb2.content_ids() == cids );
  assert( cb2.has_events() );
  assert( cb2.event_ids() == eids );

  msg("Create content.");
  Content con1;
  assert( con1.front().is_empty() );
  con1.merge(cb1);
  assert( con1.front() == cb1 );
  con1.merge(cb2);
  cout << con1 << endl;
  assert( con1.blocks().size() == 2 );
  assert( ! con1.is_empty() );
  assert( con1.is_compact() );
  assert( con1.has_event_content() );
  assert( con1.has_nonevent_content() );
  size_t mem = con1.memsize();
  cout << "memsize = " << mem << endl;
  assert( mem > cb1.memsize() );

  msg("Copy");
  Content con2 = con1;
  cout << con2 << endl;
  assert( con2 == con1 );

  msg("Write XML");
  const XmlElement* pele = con1.xml();
  assert( pele != 0 );
  assert( pele->is_valid() );
  cout << * pele << endl;

  msg("Create from XML");
  Content con3(*pele);
  cout << con3 << endl;
  assert( con3 == con1 );

  msg("Write DTD");
  Text dtd = Content::dtd();
  cout << dtd << endl;
  assert( dtd.size() );

  msg("Check event content");
  Content con4 = con1.event_content();
  cout << con4 << endl;
  assert( con4.blocks().size() == 1 );
  assert( con4.blocks().front() == cb2 );
  assert( con4.has_event_content() );
  assert( ! con4.has_nonevent_content() );

  msg("Check nonevent content");
  Content con5 = con1.nonevent_content();
  cout << con5 << endl;
  assert( con5.blocks().size() == 1 );
  assert( con5.blocks().front() == cb1 );
  assert( ! con5.has_event_content() );
  assert( con5.has_nonevent_content() );

  msg("Create new block without events");
  ContentIdList cids2;
  cids2.insert(ContentId("Test4", "key4"));
  cids2.insert(ContentId("Test5", "key5"));
  cids2.insert(ContentId("Test6", "key6"));
  ContentBlock cb3("NoEventDataset", "no-events", cids2);
  cout << cb3 << endl;

  msg("Create new block with old events");
  ContentBlock cb4("EventDataset", "events", cids2, eids);
  cout << cb4 << endl;
  assert( cb4.is_valid() );

  msg("Create block with old content and new events");
  EventIdList eids2;
  eids2.insert(EventIdRange(1001, 9600, 9699));
  ContentBlock cb5("EventDataset", "events", cids, eids2);
  cout << cb5 << endl;
  assert( cb5.is_valid() );

  msg("Create block with new content and new events");
  ContentBlock cb6("EventDataset", "events", cids2, eids2);
  cout << cb6 << endl;
  assert( cb6.is_valid() );

  msg("No-event merge");
  cout << "--- old" << endl;
  Content con6 = con1;
  cout << con6 << endl;
  con6.merge(cb3);
  cout << "--- new" << endl;
  cout << con6 << endl;
  assert( con6.is_valid() );
  assert( con6.blocks().size() == 2 );
  assert( con6.nonevent_content().blocks().front().content_ids().size() == 6 );

  msg("Event merge: old-old + new-old");
  Content con7 = con1;
  cout << "--- old" << endl;
  cout << con7 << endl;
  con6.merge(cb4);
  cout << "--- new" << endl;
  cout << con6 << endl;
  assert( con6.is_valid() );
  assert( con6.event_content().blocks().size() == 1 );
  assert( con6.event_content().blocks().front().content_ids().size() == 6 );

  msg("Event merge: old-old + new-old + old-new");
  con6.merge(cb5);
  cout << con6 << endl;
  assert( con6.is_valid() );
  assert( con6.event_content().blocks().size() == 2 );

  msg("Event merge: old-old + new-old + old-new + new-new");
  con6.merge(cb6);
  cout << con6 << endl;
  assert( con6.is_valid() );
  assert( con6.event_content().blocks().size() == 1 );
  assert( con6.event_content().blocks().front().content_ids().size() == 6 );
  assert( con6.event_content().blocks().front().event_ids().size() == 200 );

  msg("Append content");
  Content con8;
  con8.merge(cb4);
  assert( con1.blocks().size() == 2 );
  assert( con8.blocks().size() == 1 );
  con8.push_back(con1);
  cout << con8 << endl;
  assert( con8.is_valid() );
  assert( con8.blocks().size() == 3 );

  msg("Merge content");
  Content con9;
  con9.merge(cb4);
  assert( con1.blocks().size() == 2 );
  assert( con9.blocks().size() == 1 );
  con9.merge(con1);
  cout << con9 << endl;
  assert( con9.is_valid() );
  assert( con9.blocks().size() == 2 );

  msg("Create single block content w/o events");
  Content con10("NoEventDataset", "no-events", cids);
  cout << con10 << endl;
  assert( con10.is_valid() );
  assert( con10.blocks().size() == 1 );
  assert( con10.blocks().front() == cb1 );

  msg("Create single block content w/o events");
  Content con11("EventDataset", "events", cids, eids);
  cout << con11 << endl;
  assert( con11.is_valid() );
  assert( con11.blocks().size() == 1 );
  assert( con11.blocks().front() == cb2 );

  return 0;
}

#ifdef CTEST_MAIN
int main() {
  return Content_t();
}
#endif