package org.modeshape.jcr;

import static org.junit.Assert.assertEquals;

import org.apache.jackrabbit.core.RepositoryImpl;
import org.apache.jackrabbit.core.config.ConfigurationException;
import org.apache.jackrabbit.core.config.RepositoryConfig;
import org.exoplatform.container.StandaloneContainer;
import org.exoplatform.services.jcr.RepositoryService;
import org.exoplatform.services.jcr.config.RepositoryConfigurationException;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import javax.jcr.PathNotFoundException;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.SimpleCredentials;
import javax.jcr.UnsupportedRepositoryOperationException;
import javax.jcr.observation.Event;
import javax.jcr.observation.EventIterator;
import javax.jcr.observation.EventListener;
import javax.jcr.observation.EventListenerIterator;

public class TestJCRObservation {

  protected final static Logger LOG = LoggerFactory.getLogger("org.modeshape.jcr.TestJCRObservation");

  private Repository repository;

  private Session sessionDefault;

  private TesterEventListener listenerDefault;

  private Session sessionAnother;

  private TesterEventListener listenerAnother;

  class TesterEventListener implements EventListener {

	int nodesAdded = 0;

	public void onEvent(EventIterator events) {
	  while (events.hasNext()) {
		Event event = events.nextEvent();
		switch (event.getType()) {
		case Event.NODE_ADDED:
		  nodesAdded++;
		  break;
		default:
		  break;
		}
	  }
	}
  }

  private TesterEventListener addListener(Session session) throws UnsupportedRepositoryOperationException,
	  RepositoryException {
	TesterEventListener listener = new TesterEventListener();
	session
	    .getWorkspace()
	    .getObservationManager()
	    .addEventListener(
	        listener,
	        Event.NODE_ADDED | Event.NODE_REMOVED | Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED
	            | Event.PROPERTY_REMOVED, "/", true, null, null, false);

	return listener;
  }

  private void removeListeners(Session session) throws UnsupportedRepositoryOperationException, RepositoryException {

	for (EventListenerIterator iter = session.getWorkspace().getObservationManager().getRegisteredEventListeners(); iter
	    .hasNext();) {
	  session.getWorkspace().getObservationManager().removeEventListener(iter.nextEventListener());
	}
  }

  private Session loginJackrabbit(String workspaceName) throws ConfigurationException, FileNotFoundException,
	  RepositoryException {

	if (repository == null) {
	  File jrroot = new File("target/jackrabbit");
	  File wsroot = new File(jrroot, "workspaces");
	  wsroot.mkdirs();

	  repository = RepositoryImpl.create(RepositoryConfig.create(new FileInputStream(
		  "src/test/resources/conf/jackrabbit/repository.xml"), jrroot.getAbsolutePath()));
	}

	return repository.login(new SimpleCredentials("adminId", "admin".toCharArray()), workspaceName);
  }

  private Session loginExoJcr(String workspaceName) throws Exception {

	if (repository == null) {
	  String containerConf = "src/test/resources/conf/exojcr/standalone/configuration.xml";

	  StandaloneContainer.addConfigurationPath(containerConf);
	  StandaloneContainer servicesManager = StandaloneContainer.getInstance();

	  if (System.getProperty("java.security.auth.login.config") == null) {
		System.setProperty("java.security.auth.login.config", "src/test/resources/conf/exojcr/standalone/login.conf");
	  }

	  RepositoryService repositoryService = (RepositoryService) servicesManager
		  .getComponentInstanceOfType(RepositoryService.class);

	  repository = repositoryService.getRepository("repository");
	}

	return repository.login(new SimpleCredentials("root", "exo".toCharArray()), workspaceName);
  }

  private Session loginModeShape(String workspaceName) throws ConfigurationException, RepositoryException, IOException,
	  SAXException {

	if (repository == null) {
	  // Load the configuration from a file
	  JcrConfiguration configuration = new JcrConfiguration();
	  configuration.loadFrom("src/test/resources/conf/modeshape/config-repository.xml");

	  // Now create the JCR engine ...
	  JcrEngine engine = configuration.build();
	  engine.start();

	  repository = engine.getRepository("repository");
	}

	return repository.login(workspaceName);
  }

  /**
   * setUp.
   * 
   * @throws java.lang.Exception
   */
  @Before
  public void setUp() throws Exception {

	// login in default workspace
	sessionDefault = loginModeShape("default");
	// login in another workspace
	sessionAnother = loginModeShape("another");

	listenerDefault = addListener(sessionDefault);
	listenerAnother = addListener(sessionAnother);
  }

  @After
  public void tearDown() throws Exception {
	removeListeners(sessionDefault);
	removeListeners(sessionAnother);

	try {
	  sessionDefault.getRootNode().getNode("nodeA").remove();
	  sessionDefault.save();
	} catch (PathNotFoundException e) {
	  // seems nodeA wasn't created
	}
	
	sessionDefault.logout();
	sessionAnother.logout();
  }

  /**
   * @throws Exception
   */
  @Test
  public void shouldNotReceiveFromOtherWorkspaces() throws Exception {

	sessionDefault.getRootNode().addNode("nodeA", "nt:unstructured");
	sessionDefault.getRootNode().save();

	// wait a bit for observation thread
	Thread.yield();
	Thread.sleep(100);
	
	assertEquals("One node added should be observed", 1, listenerDefault.nodesAdded);
	assertEquals("No one node added in another workspace, nothing should be observed", 0, listenerAnother.nodesAdded);
  }

}