#include "dbxml/DbXml.hpp"

#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <regex.h>
#include <xqilla/xqilla-simple.hpp>

using namespace DbXml;
// exception handling omitted for clarity
XERCES_CPP_NAMESPACE_USE

int main(void)
{
  u_int32_t env_flags = DB_CREATE     |  // If the environment does not
                                         // exist, create it.
    DB_INIT_LOCK  |  // Initialize the locking subsystem
    DB_INIT_LOG   |  // Initialize the logging subsystem
    DB_INIT_MPOOL |  // Initialize the cache
    DB_INIT_TXN;     // Initialize transactions;
  std::string envHome("./testEnv");
  DbEnv myEnv(0);
  
  u_int32_t db_flags = DB_CREATE | DB_AUTO_COMMIT;
  Db *dbp = NULL;
  const char *file_name = "mydb.db";
  
  try {
    myEnv.open(envHome.c_str(), env_flags, 0);
  } catch(DbException &e) {
    std::cerr << "1) Error opening database environment: "
              << envHome << std::endl;
    std::cerr << e.what() << std::endl;
  } catch(std::exception &e) {
    std::cerr << "2) Error opening database environment: "
              << envHome << std::endl;
    std::cerr << e.what() << std::endl;
  } 
  
  // Do BDB XML work here
  u_int32_t containerFlags =
              DB_CREATE |        // If the container does not exist,
                                 // create it.
              DBXML_TRANSACTIONAL;  // Enable transactions.

  // Open an XmlManager
  XmlManager myManager = XmlManager(&myEnv, 0);
  //XmlContainer sortzeko = myManager->createContainer("./estEnv/EPEC_formaka.dbxml");
  XmlContainer myQueryContainer = myManager.createContainer("/home/jalberdi004/fsak/testEnv/EPEC_formaka.dbxml");//,containerFlags,XmlContainer::NodeContainer);
  XmlContainer myUpdateContainer = myManager.openContainer ("/home/jalberdi004/fsak/testEnv/EPEC_formaka.dbxml");//,containerFlags);
  XmlUpdateContext updateContext = myManager.createUpdateContext();
  XmlQueryContext queryContext = myManager.createQueryContext();
  myManager.setDefaultContainerType(XmlContainer::NodeContainer);

  myQueryContainer.addIndex("str indizea","str","edge-element-equality-string",updateContext);
  myQueryContainer.addIndex("sym indizea, agian kentzeko","sym","edge-element-equality-string",updateContext);
  myQueryContainer.addIndex("value indizea","value","edge-attribute-equality-string",updateContext);
  XmlIndexSpecification indizeak = myQueryContainer.getIndexSpecification();


  queryContext.setVariableValue("forma", ""); 
  //queryContext.setBaseURI("file:///data2/datuBasea/");
  queryContext.setEvaluationType(XmlQueryContext::Lazy);
  std::string galdera = "collection(\"testEnv/EPEC_formaka.dbxml\")/fs[f[@name=\"forma\"]/str=\"$forma\"]/@id";
  XmlQueryExpression qe = myManager.prepare(galdera, queryContext);
   
  DIR * directory;
  struct dirent * entry;
  int i = 0;
  int luzera;
  char document[100];
  directory = opendir(".");
  //. eta .. kentzeko
  entry = readdir (directory);
  entry = readdir (directory);
  int emaitzaKop;
  std::string forma;
  int iterazioak = 0;
  //XmlTransaction transaction = XmlTransaction() ;
  while ((entry = readdir (directory)) && iterazioak < 1000){
    XmlTransaction transaction = myManager.createTransaction();
    std::cout << std::endl << i << " datu basea eguneratzen..." << std::endl;

    //galdera.clear();
    //galdera = "collection(\"EPEC_formaka.dbxml\")/fs[f[@name=\"forma\"]/str=\"";//etxe\"]/@id";
    forma.clear(); //forma hutsa hasieratu
    std::string fitxIzena ="/home/jalberdi004/fsak/";
    fitxIzena += entry->d_name;   

    std::cout << "fitx izena: " << fitxIzena << std::endl;

    if (strstr(entry->d_name,"osatu")){
      printf("osatu haurkitu delako ateratzen da. %s\n",entry->d_name);
      transaction.abort();
      continue;
    }

    //forma bilatu

    // Initialise Xerces-C and XQilla by creating the factory object
    XQilla xqilla;
    
    // Parse an XQuery expression
    // (AutoDelete deletes the object at the end of the scope)
    AutoDelete<XQQuery> query(xqilla.parse(X("/fs/f[@name='forma']/data(str)")));
    
    // Create a context object
    try{
      AutoDelete<DynamicContext> contextXqilla(query->createDynamicContext());
      
      // Parse a document, and set it as the context item
      Sequence seq = contextXqilla->resolveDocument(X(fitxIzena.c_str()), 0);
      if(!seq.isEmpty() && seq.first()->isNode()) {
	contextXqilla->setContextItem(seq.first());
	contextXqilla->setContextPosition(1);
	contextXqilla->setContextSize(1);
      }
      // Execute the query, using the context
      Result result = query->execute(contextXqilla);
      

      // Iterate over the results, printing them
      Item::Ptr item;
      if(item = result->next(contextXqilla)) {
	forma = UTF8(item->asString(contextXqilla));
	//std::cout << UTF8(item->asString(context)) << std::endl;
      }
      //fitxategian ez dago FS bat edo bat baino gehiago daude
      else{
	i++;
	transaction.abort();
	continue;
      }
    } catch(...){
      std::string komandoa = "cp ";
      komandoa += fitxIzena;
      komandoa += " ../zaborra/";
      komandoa += entry->d_name;
      system(komandoa.c_str());
      std::cerr << "erroretik irtengo da" << std::endl;
      i++;
      transaction.abort();
      continue;
    }

    //dokumentutik atera forma
    queryContext.setVariableValue("forma", forma); 


    std::cout << "forma: " << forma << std::endl;
    std::cout << "galdera: " << galdera << std::endl;

    //datu basean bilatu
    try {

      //XmlQueryExpression qe = myManager.prepare(galdera, queryContext);
      XmlResults results = qe.execute(queryContext);
      //3XmlResults results = myManager.query(galdera,queryContext);
      XmlValue value;
      emaitzaKop = 0;
      while (results.next(value) && i<1) {    
	emaitzaKop++;
	XmlDocument theDoc = value.asDocument();
	std::string docName = theDoc.getName();
	std::string docString = value.asString();
	
	//std::cout << "Document " << docName << ":" << std::endl;
	std::cout << "galderaren erantzuna" <<docString << std::endl;
	//std::cout << "===============================\n" << std::endl;
      }   
    } catch (XmlException &e) {
      std::cerr << "***errorea galdera egitean" << std::endl << e.what()<< std::endl;
    }
    
    //datu basean ez dago eta sartu behar da
    if (emaitzaKop==0) {
      
      std::cout << "fitxategia gordetzen... " << std::endl;
      //XmlUpdateContext context = myManager.createUpdateContext();
      luzera=strlen(entry->d_name)-4;
      strncpy(document,entry->d_name,luzera);
      document[luzera]='\0';

      std::string docName = document;
      std::string documentName = entry->d_name;
      std::string docType;
      std::string zatiak[15]; 
      std::cout << "fitx izena: " << fitxIzena << " \ndokumentu izena: " << docName << std::endl;
      char * cstr,*p;
      cstr = new char [documentName.size()+1];
      strcpy (cstr, docName.c_str());
      p=strtok(cstr,".");   
      while (p != NULL){
	//printf("%s\n",p);
	docType = p;
	std::cout << "\t docType = "  <<p << std::endl;
	p=strtok(NULL,".");
	
      }  
      
      try {
	
	// Get the input stream.
	XmlInputStream *theStream = 
	  myManager.createLocalFileInputStream(fitxIzena);
	
	// Put the document
	myUpdateContainer.putDocument(transaction,  //transaction object
				      docName,      // The document's name
				      theStream,      // The actual document. 
				      updateContext,     // The update context 				  // (required).
				      DBXML_WELL_FORMED_ONLY);             // Put flags.//DTDa ez balidatzeko
      } catch (XmlException &e) {
	std::cerr << "***errorea fitxategia gordetzean" << std::endl << e.what()<< std::endl;
	transaction.abort();
	// Error handling goes here. You may want to check
	// for XmlException::UNIQUE_ERROR, which is raised
	// if a document with that name already exists in
	// the container. If this exception is thrown, 
	// try the put again with a different name, or
	  // use XmlModify to update the document.
      }
      i++;

    }
    std::cout << "Emaitza kopurua:" << emaitzaKop << std::endl;
    
    transaction.commit();
    iterazioak++; 
  }

  try {
    myEnv.close(0);
  } catch(DbException &e) {
    std::cerr << "1) Error closing database environment: "
              << envHome << std::endl;
    std::cerr << e.what() << std::endl;
  } catch(std::exception &e) {
    std::cerr << "2) Error closing database environment: "
              << envHome << std::endl;
    std::cerr << e.what() << std::endl;
  } 
  std::cout << "bukatu da" << std::endl;
  return (0);
  
}