/*
    * Copyright James Leigh (c) 2007.
    *
    * Licensed under the Aduna BSD-style license.
    */
   package org.openrdf.repository.memento;
   
   import java.util.ArrayList;
   import java.util.List;
  
  import org.openrdf.model.Resource;
  import org.openrdf.model.URI;
  import org.openrdf.model.Value;
  import org.openrdf.repository.DelegatingRepositoryConnection;
  import org.openrdf.repository.RepositoryConnection;
  import org.openrdf.repository.RepositoryException;
  import org.openrdf.repository.event.NotifyingRepository;
  import org.openrdf.repository.event.NotifyingRepositoryConnection;
  import org.openrdf.repository.event.RepositoryConnectionListener;
  import org.openrdf.repository.event.base.NotifyingRepositoryConnectionWrapper;
  
  /**
   * Tracks changes to a RepositoryConnection and allows those changes to be
   * reversed. There is a performance hit when this object is attached to a
   * RepositoryConnection. This object depends on {@link NotifyingRepository} to
   * be on the stack. If the repository does not support or have enabled read
   * uncommitted, the {@link StatementRealizerRepository} must be a delegate of
   * {@link NotifyingRepository}.
   * 
   * @author James Leigh
   * 
   */
  public class RepositoryMemento implements RepositoryConnectionListener {
  
  	private NotifyingRepositoryConnection conn;
  
  	private List<Command> committed;
  
  	private List<Command> active;
  
  	private RepositoryException exc;
  
  	public RepositoryMemento(RepositoryConnection conn)
  			throws RepositoryException {
  		this(findNotifier(conn));
  	}
  
  	public RepositoryMemento(NotifyingRepositoryConnection conn) {
  		this.conn = conn;
  		this.active = new ArrayList<Command>();
  		this.conn.addRepositoryConnectionListener(this);
  		if (conn instanceof NotifyingRepositoryConnectionWrapper) {
  			NotifyingRepositoryConnectionWrapper w;
  			w = (NotifyingRepositoryConnectionWrapper) conn;
  			w.setReportDeltas(true);
  		}
  	}
  
  	public void close(RepositoryConnection conn) {
  		stopListening();
  	}
  
  	public void setAutoCommit(RepositoryConnection conn, boolean autoCommit) {
  		synchronized (active) {
  			if (committed == null) {
  				committed = new ArrayList<Command>(active);
  			} else {
  				committed.addAll(active);
  			}
  			active.clear();
  		}
  	}
  
  	public void commit(RepositoryConnection conn) {
  		setAutoCommit(conn, true);
  	}
  
  	public void rollback(RepositoryConnection conn) {
  		synchronized (active) {
  			active.clear();
  		}
  	}
  
  	public void add(RepositoryConnection conn, Resource subj, URI pred,
  			Value obj, Resource... contexts) {
  		addCommand(new AddCommand(subj, pred, obj, contexts));
  	}
  
  	public void remove(RepositoryConnection conn, Resource subj, URI pred,
  			Value obj, Resource... contexts) {
  		if (subj == null || pred == null || obj == null || contexts == null || contexts.length == 0)
  			throw new UnsupportedOperationException("RepositoryMemento is only supported when reporting deltas is enabled");
  		addCommand(new RemoveCommand(subj, pred, obj, contexts));
  	}
  
  	public void clear(RepositoryConnection conn, Resource... contexts) {
  		throw new UnsupportedOperationException("RepositoryMemento is only supported when reporting deltas is enabled");
  	}
  
 	public void setNamespace(RepositoryConnection conn, String prefix,
 			String name) {
 		try {
 			String namespace = conn.getNamespace(prefix);
 			Command command = new OverrideNamespaceCommand(prefix, namespace,
 					name);
 			addCommand(command);
 		} catch (RepositoryException e) {
 			handleException(e);
 		}
 	}
 
 	public void removeNamespace(RepositoryConnection conn, String prefix) {
 		try {
 			String namespace = conn.getNamespace(prefix);
 			Command command = new OverrideNamespaceCommand(prefix, namespace,
 					null);
 			addCommand(command);
 		} catch (RepositoryException e) {
 			handleException(e);
 		}
 	}
 
 	public void clearNamespaces(RepositoryConnection conn) {
 		throw new UnsupportedOperationException("RepositoryMemento is only supported when reporting deltas is enabled");
 	}
 
 	/**
 	 * After this object has recorded changes to a connection, it can be
 	 * reverted with this method. This RepositoryConnection does not have to be
 	 * the same connection that this object was attached to.
 	 * 
 	 * @param conn
 	 * @throws RepositoryException
 	 */
 	public void undo(RepositoryConnection conn) throws RepositoryException {
 		if (exc != null)
 			throw exc;
 		stopListening();
 		synchronized (active) {
 			boolean autoCommit = conn.isAutoCommit();
 			conn.setAutoCommit(false);
 			undo(active, conn);
 			if (committed != null)
 				undo(committed, conn);
 			conn.setAutoCommit(autoCommit);
 		}
 	}
 
 	/**
 	 * After this object has recorded changes to a connection, it can be
 	 * repeated with this method. This RepositoryConnection does not have to be
 	 * the same connection that this object was attached to.
 	 * 
 	 * @param conn
 	 * @throws RepositoryException
 	 */
 	public void redo(RepositoryConnection conn) throws RepositoryException {
 		if (exc != null)
 			throw exc;
 		stopListening();
 		synchronized (active) {
 			boolean autoCommit = conn.isAutoCommit();
 			conn.setAutoCommit(false);
 			if (committed != null)
 				redo(committed, conn);
 			redo(active, conn);
 			conn.setAutoCommit(autoCommit);
 		}
 	}
 
 	private void undo(List<Command> commands, RepositoryConnection conn)
 			throws RepositoryException {
 		for (int i = commands.size() - 1; i >= 0; i--) {
 			Command command = commands.get(i);
 			command.undo(conn);
 		}
 	}
 
 	private void redo(List<Command> commands, RepositoryConnection conn)
 			throws RepositoryException {
 		for (Command command : commands) {
 			command.redo(conn);
 		}
 	}
 
 	private void addCommand(Command command) {
 		synchronized (active) {
 			active.add(command);
 		}
 	}
 
 	private void handleException(Exception e) {
 		if (e instanceof RepositoryException) {
 			exc = (RepositoryException) e;
 		} else if (e.getCause() instanceof RepositoryException) {
 			exc = (RepositoryException) e.getCause();
 		} else {
 			throw new AssertionError(e);
 		}
 		stopListening();
 	}
 
 	private static NotifyingRepositoryConnection findNotifier(
 			RepositoryConnection conn) throws RepositoryException {
 		if (conn instanceof NotifyingRepositoryConnectionWrapper) {
 			return (NotifyingRepositoryConnection) conn;
 		}
 		if (conn instanceof DelegatingRepositoryConnection) {
 			DelegatingRepositoryConnection dconn = (DelegatingRepositoryConnection) conn;
 			return findNotifier(dconn.getDelegate());
 		}
 		throw new IllegalArgumentException(
 				"Repository stack does not contain notification support");
 	}
 
 	private void stopListening() {
 		conn.removeRepositoryConnectionListener(this);
 		conn = null;
 	}
 }