package org.gcube.informationsystem.collector.impl.xmlstorage.exist;

import org.xmldb.api.base.XMLDBException;
import org.xmldb.api.base.Collection;
import org.xmldb.api.base.Database;
import org.xmldb.api.DatabaseManager;
import org.xmldb.api.modules.XMLResource;
import org.xmldb.api.modules.CollectionManagementService;

import org.exist.xmldb.DatabaseInstanceManager;

import org.exist.storage.DBBroker;

import org.gcube.common.core.utils.logging.GCUBELog;
import org.gcube.informationsystem.collector.impl.contexts.ICServiceContext;
import org.gcube.informationsystem.collector.impl.xmlstorage.exist.XMLStorage;

import org.gcube.informationsystem.collector.impl.resources.GCUBEXMLResource;
import org.gcube.informationsystem.collector.impl.resources.GCUBEXMLResource.MalformedXMLResourceException;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * A thread safe manager to interact with the XML Storage repository.
 * 
 * RESOURCE the type of the resource to store
 * 
 * @author Manuele Simi (ISTI-CNR)
 * 
 */
public class XMLStorage {

    protected static String URI = "xmldb:exist://";
    
    protected static String USER = "admin";
    
    protected static String PWD = "";

    protected static String driver = "org.exist.xmldb.DatabaseImpl";

    private static GCUBELog logger = new GCUBELog(XMLStorage.class);

    private Database database;

    // private Collection currentCollection;

    protected Collection rootCollection;

    protected Lock lock;
    
    // lock for writing operations
    private Lock writeLock;
    
    // lock for reading operations
    protected Lock readLock;
    
    // flag to warn when the DB is locked
    private boolean locked = false;

    //private static final String PROPERTIES_COLLECTION_NAME = "Properties";

    //protected static String PROFILES_COLLECTION_NAME = "Profiles";

    enum STATUS {INITIALISED, CLOSED, SHUTDOWN};
    
    private STATUS status = STATUS.CLOSED;
    
    protected long maxOperationsPerConnection = 1000;
    
    protected long operationsCounter = 0;
    
    
    /**
     * Creates a new manager
     * 
     */
    public XMLStorage() {
	logger.debug("Creating a new XMLStorage");
	lock = new ReentrantLock();
	writeLock = lock;
	readLock = lock;
    }


    /**
     * Initializes the local XML Storage repository 
     * @param lock  if the storage has to be locked or not during the initalization
     * 
     * @throws Exception if the connection to eXist or its initialization fail
     */
    public void initialize(boolean ... lock) throws XMLStorageNotAvailableException {
	this.initialize(this.maxOperationsPerConnection, lock);
    }
    /**
     * Initializes the local XML Storage repository
     * @param maxOperationsPerConnection max number of operation per active connection
     * @param lock  if the storage has to be locked or not during the initalization
     * 
     * @throws Exception if the connection to eXist or its initialization fail
     */
    public void initialize(long maxOperationsPerConnection, boolean ... lock) throws XMLStorageNotAvailableException {
	
	if (this.getStatus() == STATUS.INITIALISED) {
	    logger.warn("XMLStorage already initialized");
	    return;
	}
	   // lock the instance
	if (lock != null && lock.length > 0 && lock[0]) {
	    this.lock();
	}
	try {
	    logger.info("Initializing XMLStorage...");
	    // this.printEnv();
	    this.maxOperationsPerConnection = maxOperationsPerConnection;//Long.valueOf((String) ICServiceContext.getContext().getProperty("maxOperationsPerConnection", true));

	    // register/create the DB instance
	    Class<?> cl = Class.forName(driver);
	    this.database = (Database) cl.newInstance();
	    database.setProperty("create-database", "true");
	    DatabaseManager.registerDatabase(this.database);	    

	    // try to load the collections for props and profiles
	    logger.info("Initializing the root collection");
	    this.rootCollection = DatabaseManager.getCollection(URI + DBBroker.ROOT_COLLECTION, USER, PWD);
	    if (this.rootCollection == null) {
		logger.error("invalid root collection!");
		throw new XMLStorageNotAvailableException("unable to load root collection");
	    }	   
	    this.rootCollection.setProperty("pretty", "true");
	    this.rootCollection.setProperty("encoding", "UTF-8");	    
	    this.setStatus(STATUS.INITIALISED);
	   
	    logger.info("XMLStorage initialized with success");
	} catch (XMLDBException edb) {
	    logger.error("unable to initialize XML storage ", edb);
	    throw new XMLStorageNotAvailableException("unable to initialize XML storage");
	} catch (Exception e) {
	    logger.error("unable to initialize XML storage ", e);
	    throw new XMLStorageNotAvailableException("unable to initialize XML storage");
	} catch (java.lang.NoClassDefFoundError ncdfe) {
	    logger.error("unable to initialize XML storage", ncdfe);
	    throw new XMLStorageNotAvailableException("unable to initialize XML storage");
	} finally {
	    if (lock != null && lock.length > 0 && lock[0]) {
	      this.unlock();
	    }
	}

    }
    
    /**
     * Creates a collection in the XML storage. If the input includes a full path, collections are created recursively
     * @param name the collection to create
     * @return the created collection
     * @throws XMLDBException 
     * @throws XMLStorageNotAvailableException
     */
    public Collection createCollection(String name) throws XMLDBException, XMLStorageNotAvailableException {
	logger.info("Initializing the collection " + name);
	String[] subcollections = name.split("/");
	Collection parent = this.rootCollection;
	for (String subcollection : subcollections) {
	    Collection child = parent.getChildCollection(subcollection);
	    if (child == null) {
		child = this.createCollection(parent, subcollection);
		if (child == null)
		    throw new XMLStorageNotAvailableException("unable to create collection " + name);
		else {
		    child.setProperty("pretty", "true");
		    child.setProperty("encoding", "UTF-8");
		}
	    }
	    parent = child;
	}
	return parent;
    }
    
    /**
     * Blocks all the writing operations
     */
    protected void lock() {
	writeLock.lock();
	this.locked = true;
	logger.trace("WRITE LOCK acquired");
	
    }

    /**
     * Unblocks all the writing operations
     */
    protected void unlock() {
	writeLock.unlock();	
	this.locked = false;
	logger.trace("WRITE LOCK released");
    }
    

    /**
     * Shutdowns the XML Storage repository
     * 
     * @return true if the operation succeed
     */
    public boolean shutdown(boolean lock) {
	if (lock) 
    	  this.lock();
	
	logger.info("XML storage is shutting down");
	try {
	    DatabaseInstanceManager manager = (DatabaseInstanceManager) rootCollection.getService("DatabaseInstanceManager", "1.0");
	    manager.shutdown();
	    this.setStatus(STATUS.SHUTDOWN);
	    logger.info("...XML storage is down");
		if (lock) 
		    this.lock();			
	} catch (XMLDBException edb) {
	    logger.fatal("Unable to shutdown XML storage", edb);	    
	} 
	return true;
    }

    private Collection loadCollection(String collectionName) {
	return this.loadCollection(this.rootCollection, collectionName);
    }
    
    /**
     * Loads a collection. If it does not exist, the collection is created.
     * 
     * @param parentCollection
     *            the parent collection of the collection to load
     * @param collectionName
     *            name of the collection to load
     * @return the collection
     */
    private Collection loadCollection(Collection parentCollection, String collectionName) {
	// set the current collection
	Collection currentCollection = null;
	try {
	    currentCollection = parentCollection.getChildCollection(collectionName);
	    if (currentCollection == null) {
		// the collection does not exist, it is created
		logger.info("Creating a new collection " + collectionName + "...");
		currentCollection = this.createCollection(parentCollection, collectionName);
	    }
	    currentCollection.setProperty("pretty", "true");
	    currentCollection.setProperty("encoding", "UTF-8");
	} catch (XMLDBException edb) {
	    logger.error("failed to create collection " + collectionName + "!");
	    logger.error("" + edb.getCause());

	} catch (java.lang.NullPointerException e) {
	    logger.fatal("the XMLStorage is GONE!! a Restore is needed");
	    
	}
	return currentCollection;
    }

    /**
     * Discards the current collection
     * 
     */
    protected void resetCollection(Collection currentCollection) {
	try {
	    currentCollection.close();
	} catch (XMLDBException edb) {
	    // Catch any issues with closing the exception.
	    logger.error("unable to close collection " + edb.getMessage());
	}
	currentCollection = null;
    }

    /**
     * Loads the collection containing the WS-ResourceProperties documents. It must be used when
     * quering/storing/updating WS-ResourceProperties documents
     * 
     * @return the Collection
     */
    /*public Collection loadPropertiesCollection() {
	logger.debug("Loading collection Properties... ");
	return this.loadCollection(this.rootCollection, XMLStorage.PROPERTIES_COLLECTION_NAME);
    } */

    /**
     * Loads from the children of the Profile Collection, the collection identified by the given
     * name. It must be used when quering/storing/updating a particular kind of profile
     * 
     * @param collectionName
     *            the child collection of the Profile collection to load
     * @return the Collection
     */
   /* public Collection loadProfileCollection(String collectionName) {
	logger.debug("Loading collection " + collectionName + "... ");
	return this.loadCollection(this.profilesRootCollection, collectionName);
    }*/

    /**
     * Loads the parent collection of all collections containing resources profiles. It must be used
     * when quering all the profiles at the same time
     * 
     * @return the Collection
     */
    /*public Collection loadAllProfilesCollection() {
	logger.debug("Loading all profiles collection... ");
	return this.loadCollection(this.rootCollection, XMLStorage.PROFILES_COLLECTION_NAME);
    }*/

    /**
     * Loads the root collection. It must be used when quering all the information maintained by the
     * DB instance at the same time
     * 
     * @return the Collection
     */
    public Collection loadAllCollections() {

	Collection currentCollection = null;
	logger.debug("Loading all collections... ");
	// return this.loadCollection(this.rootCollection,
	// XMLStorage.PROFILES_COLLECTION_NAME);
	try {
	    currentCollection = DatabaseManager.getCollection(URI + DBBroker.ROOT_COLLECTION, USER, PWD);
	} catch (XMLDBException edb) {
	    logger.error("Failed to load all collections!");
	    logger.error("", edb);
	}
	return currentCollection;
    }

    /**
     * Stores a XMLDBDocument in the current collection. If the resource already
     * exists in the storage, it is updated.
     * 
     * @param resource
     *            the resource to store
     * @throws MalformedXMLResourceException 
     * @throws Exception
     *             if the storing fails
     */
    public void storeResource(GCUBEXMLResource resource) throws XMLStorageNotAvailableException, MalformedXMLResourceException {

	this.lock();	
	if (status != STATUS.INITIALISED) {
	    this.unlock();
	    throw new XMLStorageNotAvailableException("XMLStorage not initialized");
	}
	    
	Collection currentCollection = this.loadCollection(resource.getCollectionName());    

	if (currentCollection == null) {
	    logger.error("Unable to open the Collection");
	    this.unlock();
	    throw new XMLStorageNotAvailableException("Unable to open the Collection");
	}
	
	try {
	    XMLResource document = (XMLResource) currentCollection.createResource(resource.getResourceName(), "XMLResource");
	    document.setContent(resource.toString());	    
	    logger.debug("Storing/updating resource " + document.getId() + " in collection " + currentCollection.getName() + "...");
	    logger.trace("Resource content: " + resource.toString());
	    currentCollection.storeResource(document);
	    logger.debug("...done");
	} catch (XMLDBException edb) {
	    logger.error("Failed to store resource " + resource.getResourceName());
	    logger.error("" + edb.errorCode + " " + edb.getMessage(), edb);
	} catch (Exception e) {
	    logger.error("" + e.getMessage(), e);
	} finally {
	    this.resetCollection(currentCollection);
	    operationsCounter++;
	    this.unlock();	    
	}
	this.checkConnection();
    }

    /**
     * 
     * @return true if the connection to eXist is locked
     */
    public boolean isLocked() {
	return this.locked;
    }

    /**
     * Retrieves a resource from the storage given its ID
     * 
     * @param resourceID
     * @return
     * @throws Exception
     */
  /*  public GCUBEXMLResource retrieveResourceFromID(String resourceID) throws Exception {
	XMLResource res = null;
	Collection currentCollection = this.loadAllCollections();
	String collectionName = currentCollection.getName();
	try {
	    res = (XMLResource) currentCollection.getResource(resourceID);
	    if (res == null)
		logger.warn("Resource " + resourceID + " not found!");
	} catch (XMLDBException edb) {
	    logger.error("Failed to retrieve document " + resourceID);
	    logger.error("" + edb.errorCode + " " + edb.getMessage(), edb);
	    throw new Exception();
	}	
	return new GCUBEXMLResource(res, collectionName);
    }
    */
    

    /**
     * Retrieves a resource's content from the storage 
     * 
     * @param resource
     * @return
     * @throws Exception
     */
    synchronized public void retrieveResourceContent(GCUBEXMLResource resource) throws Exception {
	XMLResource res = null;
	Collection currentCollection = this.loadCollection(resource.getCollectionName());
	try {
	    res = (XMLResource) currentCollection.getResource(resource.getResourceName());
	    if (res == null) {
		logger.warn("Resource " + resource.getResourceName() + " not found!");
		throw new Exception("Resource " + resource.getResourceName() + " not found!");
	    }
	    if (res.getContent() == null) {
		logger.warn("Resource content for " + resource.getResourceName() + " not found!");
		throw new Exception("Resource content for " + resource.getResourceName() + " not found!");
	    }
	    resource.setContent(res.getContent().toString(), true);
	} catch (XMLDBException edb) {
	    logger.error("Failed to retrieve document " + resource.getResourceName());
	    logger.error("" + edb.errorCode + " " + edb.getMessage(), edb);
	    throw new Exception();
	} finally {
	    this.resetCollection(currentCollection);
	}
    }

    /**
     * Checks if the resource does exist in the storage
     * @param resource the resource to check
     * @return true if the resource is stored, false otherwise
     * @throws MalformedXMLResourceException if the input resource is not valid
     */
    public boolean checkResource(GCUBEXMLResource resource) throws MalformedXMLResourceException {
	XMLResource res = null;
	Collection currentCollection = this.loadCollection(resource.getCollectionName());
	try {
	    res = (XMLResource) currentCollection.getResource(resource.getResourceName());
	} catch (XMLDBException edb) {
	    logger.warn("Resource " + resource.getResourceName() + " not found!");
	} finally {
	    this.resetCollection(currentCollection);
	}
	return (res == null)? false: true;
	
    }
    
    /**
     * 
     * @param xpathquery
     * @return
     */
    synchronized public GCUBEXMLResource executeXPathQuery(String xpathquery) {

	GCUBEXMLResource res = null;
	// ArrayList<XMLDBDocument> results = new
	// ArrayList<XMLDBDocument>();
	/*
	 * try { // get query-service XPathQueryServiceImpl service = (XPathQueryServiceImpl)
	 * currentCollection.getService("XPathQueryService", "1.0"); // set pretty-printing on
	 * service.setProperty(OutputKeys.INDENT, "yes"); service.setProperty(OutputKeys.ENCODING,
	 * "UTF-8"); ResourceSet set = service.query(xpathquery); logger.debug("number of returned
	 * documents: " + set.getSize()); ResourceIterator i = set.getIterator();
	 * while(i.hasMoreResources()) { res = new XMLDBDocument((BaseDAIXResource)
	 * i.nextResource()); System.out.println("DILIGENT resource " + i + " " + res.toString()); }
	 * 
	 * for (int i = 0; i < (int) set.getSize(); i++) { res = new
	 * XMLDBDocument((BaseDAIXResource) set.getResource((long) i));
	 * System.out.println("DILIGENT resource " + i + " " + res.toString()); } } catch
	 * (XMLDBException edb) { logger.error("failed to execute Xpath query " + xpathquery);
	 * edb.printStackTrace(); } catch (Exception e) { logger.error("exception " + xpathquery);
	 * logger.error(e.getStackTrace()); }
	 */
	return res;

    }

    /**
     * Deletes a resource 
     */
    synchronized public void deleteResource(GCUBEXMLResource resource) throws Exception {

	if (resource.getResourceName() == null) {
	    logger.warn("Invalid resource name");
	    return;
	}
	this.lock();	
	Collection collection = this.loadCollection(resource.getCollectionName());
	if (collection == null) {
	    //logger.error("Unable to load collection Properties!");
	    //throw new Exception();
	    collection = this.rootCollection;
	}
	try {
	    logger.info("Trying to remove resource " + resource.getResourceName() + " from collection " + collection.getName());
	    deleteResource(resource.getResourceName(), collection, false);
	} catch (XMLDBException edb) {
	    logger.error("Failed to remove the resource from the storage! ");
	    logger.error("", edb);
	    throw new Exception();
	} finally {
	    this.resetCollection(collection);
	    this.unlock();
	}

    }

    /**
     * Deletes a Profile resource identified by the given ID
     */
   /* synchronized public void retrieveAndDeleteProfileFromID(String profileID, String profileType) throws Exception {

	if (profileID == null) {
	    logger.warn("Invalid profile ID");
	    return;
	}
	this.lock();
	Collection profileCollection = this.loadProfileCollection(profileType);
	if (profileCollection == null) {
	    logger.error("Unable to load collection Profile!");
	    this.unlock();
	    throw new Exception("unable to load collection Profile");
	}
	try {
	    logger.info("Trying to remove profile '" + profileID + "' from collection " + profileCollection.getName());
	    deleteResource(profileID, profileCollection, false);
	} catch (Exception edb) {
	    logger.error("Failed to remove the profile from the storage! ");
	    throw new Exception(edb);		
    	} finally {
	    this.resetCollection(profileCollection);
	    this.unlock();
	}

    }*/

    /**
     * Deletes the resource with the given ID from the local storage
     * 
     * @param resourceID
     *            - the ID of the resource
     * @param col
     *            - the collection from which the resource has to be removed
     * @throws Exception
     */
    private void deleteResource(String resourceID, Collection col, boolean ... lock) throws Exception {

	XMLResource res = null;
	// lock the instance
	if (lock != null && lock.length > 0 && lock[0])
	    this.lock();	
	try {
	    res = (XMLResource) col.getResource(resourceID);
	    if (res == null)
		logger.warn("Resource " + resourceID + " not found!");
	    else {
		col.removeResource(res);
		logger.info("Resource successfully removed");
	    }
	} catch (XMLDBException edb) {
	    logger.error("Failed to retrieve resource " + resourceID);
	    throw new Exception(edb);
	} finally {
	    this.resetCollection(col);
	    if (lock != null && lock.length > 0 && lock[0])
	    	this.unlock();
	}
    }

    /**
     * Prints all the IDs of the Resources stored in the DB instance
     * 
     */
    public void printResourcesIDs() {

	String[] ress;
	Collection currentCollection = null;
	currentCollection = this.loadAllCollections();
	try {
	    if (currentCollection == null) {
		ress = this.rootCollection.listResources();
	    } else {
		ress = currentCollection.listResources();
	    }
	    for (int i = 0; i < ress.length; i++) {
		logger.debug("Resource ID:" + ress[i]);
	    }
	} catch (XMLDBException edb) {
	    logger.error("Failed to read resource IDs ", edb);
	} finally {
	    this.resetCollection(currentCollection);
	}
    }

    /**
     * Creates a new collection
     * 
     * @param collectionName
     * @return the create Collection object
     */
    private Collection createCollection(Collection parentCollection, String collectionName) {

	Collection col = null;
	this.lock();
	try {
	    CollectionManagementService mgtService = (CollectionManagementService) parentCollection.getService("CollectionManagementService", "1.0");
	    col = mgtService.createCollection(collectionName);
	} catch (XMLDBException edb) {
	    logger.error("Failed to create collection " + collectionName, edb);
	} finally {
	    this.unlock();
	}

	return col;
    }

    /**
     * Delete the collection named PROPERTIES_COLLECTION_NAME from the storage
     */
    public void deleteAllResourcesFromCollection(String collectionName) {

	this.lock();
	try {
	    //logger.info("Trying to delete the collection " + XMLStorage.PROPERTIES_COLLECTION_NAME + "...");
	    CollectionManagementService mgtService = (CollectionManagementService) rootCollection.getService("CollectionManagementService", "1.0");
	    mgtService.removeCollection(collectionName);
	    logger.info("Collection deleted");
	} catch (XMLDBException edb) {
	    logger.warn("Unable to delete the collection " + collectionName + ": " + edb.toString());
	} finally {
	    this.unlock();
	}
    }

    /**
     * Lists all the identifiers of the resources belonging the collection
     * @param collectionName the collection name
     * @return the list of identifiers
     */
    public String[] listAllCollectionResourceIDs(String collectionName) {
	return listAllCollectionResourceIDs(this.loadCollection(collectionName));//.loadPropertiesCollection());
    }

    /**
     * @return the status
     */
    public STATUS getStatus() {
	logger.trace("Status is " + status);
        return status;
    }

    /**
     * @param status the status to set
     */
    public void setStatus(STATUS status) {
	logger.trace("New status is " + status);
        this.status = status;
    }

    
    private String[] listAllCollectionResourceIDs(Collection collection) {
	String[] ids = null;
	String collectionName = "";
	try {
	    collectionName = collection.getName();
	    logger.debug("Retrieving all resource IDs from collection " + collectionName);
	    ids = new String[collection.getResourceCount()];
	    ids = collection.listResources();
	    logger.debug("Retrieved " + ids.length + " elements");
	} catch (XMLDBException edb) {
	    logger.warn("Unable to retrieve ids from collection " + collectionName + " " + edb.toString());
	}
	return ids;
    }
    
    protected void checkConnection() {
	if (this.operationsCounter > this.maxOperationsPerConnection) {
	    logger.info("It's time to reset the connection...");	   
	    this.lock();	    
	    this.shutdown(false);
	    //give a breath to the Transaction Manager
	    try {Thread.sleep(5000);} catch (InterruptedException e) {}
	    try {
		this.initialize(false);
	    } catch (XMLStorageNotAvailableException e) {
		logger.fatal("Unable to initialize XML storage", e);
	    }	    
	    this.operationsCounter = 0; 					    		
	    this.unlock();
	    logger.info("Connection reset");
	}
    }

    /**
     * Loads a file content in a String
     * 
     * @param file
     *            path and name of the file to read
     * @return the file content
     * @throws IOException
     */
    protected static String readFile(String file) throws IOException {

	BufferedReader f = new BufferedReader(new FileReader(file));
	String line;
	StringBuffer content = new StringBuffer();
	while ((line = f.readLine()) != null)
	    content.append(line);
	f.close();
	return content.toString();
    }

    /**
     * 
     * XMLStorage not initialized exception
     *
     * @author Manuele Simi (ISTI-CNR)
     *
     */
    public static class XMLStorageNotAvailableException extends Exception {
	private static final long serialVersionUID = 1L;
	public XMLStorageNotAvailableException(String message) { super(message);}

    }
}