/*
    * Copyright (c) 2005, The K-Wf Grid Consortium
    * Fraunhofer Institute for Computer Architecture and Software Technology
    * See http://www.kwfgrid.eu and http://www.first.fraunhofer.de for more details.
    */
   package net.kwfgrid.gwui.workflow;
   
   import net.kwfgrid.gworkflowdl.protocol.IncompatibleVersionsException;
   import net.kwfgrid.gworkflowdl.protocol.IllegalModificationException;
  import net.kwfgrid.gworkflowdl.protocol.IModificationHandler;
  import net.kwfgrid.gworkflowdl.protocol.IMethodCallEncoder;
  import net.kwfgrid.gworkflowdl.protocol.AbstractMethodCallStrategyExt;
  import net.kwfgrid.gworkflowdl.protocol.Protocol;
  import net.kwfgrid.gworkflowdl.protocol.service.IStructureService;
  import net.kwfgrid.gworkflowdl.protocol.calls.MethodCallException;
  import net.kwfgrid.gworkflowdl.protocol.calls.IMethodCall;
  import net.kwfgrid.gworkflowdl.protocol.structure.IStructureTask;
  import net.kwfgrid.gworkflowdl.protocol.structure.ProtocolWorkflow;
  import net.kwfgrid.gworkflowdl.protocol.client.*;
  import net.kwfgrid.gworkflowdl.structure.WorkflowFormatException;
  import net.kwfgrid.gworkflowdl.structure.CapacityException;
  
  import java.rmi.RemoteException;
  import java.io.IOException;
  import java.util.*;
  
  import org.apache.log4j.Logger;
  
  import org.glassbox.SwingThread;
  
  /***
     Implementation of <code>IClientDelegate</code> which handles all modifications of
     the structure on the Swing Event Dispatch Thread.
   */
  public class SwingClientDelegateExt extends AbstractMethodCallStrategyExt implements IClientDelegate {
      private static class CallExecution implements Runnable {
  	private IClientRootObject _structure;
  	private SwingClientDelegateExt _clientdelegate;
  	private IMethodCall _call;
  	private Object _returnvalue;
  	private Throwable _exception;
  
  	public CallExecution(SwingClientDelegateExt clientdelegate, IClientRootObject structure) {
  	    _clientdelegate = clientdelegate;
  	    _structure = structure;
  	    _call = null;
  	    _returnvalue = null;
  	    _exception = null;
  	}
  
  	public void setCall(IMethodCall call) {
  	    _call = call;
  	    _exception = null;
  	    _returnvalue = null;
  	}
  
  	public Object getReturnValue() {
  	    return _returnvalue;
  	}
  
  	public Throwable getException() {
  	    return _exception;
  	}
  
  	public boolean exceptionOccured() {
  	    return _exception != null;
  	}
  
  	public void run() {
  	    _clientdelegate.fireBeginModifications(_structure);
  	    
  	    try {
  		_returnvalue = _call.execute();
  	    } catch (Exception x) {
  		_clientdelegate.fireException(_structure, x);
  		_exception = x;
  	    }
  	    
  	    _clientdelegate.fireEndModifications(_structure);
  	}
      }
  
      private static class UpdateExecution implements Runnable {
  	private IClientRootObject _structure;
  	private SwingClientDelegateExt _clientdelegate;
  	private String[][] _updates;
  	private Throwable _exception;
  
  	public UpdateExecution(SwingClientDelegateExt clientdelegate, IClientRootObject structure) {
  	    _clientdelegate = clientdelegate;
  	    _structure = structure;
  	    _exception = null;
  	    _updates = null;
  	}
  
  	public void setUpdates(String[][] updates) {
  	    _updates = updates;
  	    _exception = null;
  	}
 
 	public Throwable getException() {
 	    return _exception;
 	}
 
 	public boolean exceptionOccured() {
 	    return _exception != null;
 	}
 
 	public void run() {
 	    _clientdelegate.fireBeginModifications(_structure);
 
 	    try {
 		for (int i=0; i<_updates.length; i++) {
 		    String version = _updates[i][0];
 		    String command = _updates[i][1];
 		    String content = _updates[i][2];
 		    _clientdelegate.handleUpdate(_structure, command, content);
 		    _structure.setVersionNumber(Integer.parseInt(version));
 		}
 	    } catch (IllegalModificationException x) {
 		_clientdelegate.fireException(_structure, x);
 		_exception = x;
 	    } catch (NumberFormatException x) {
 		_clientdelegate.fireException(_structure, x);
 		_exception = new IllegalModificationException("Could not parse version number as string.", x);
 	    }
 
 	    _clientdelegate.fireEndModifications(_structure);
 	}
     }    
 
     private static final Logger logger = Logger.getLogger(SwingClientDelegateExt.class);
 
     private IStructureService _servicestub;
     // FIXME: create a SwingClientWorkflow with has the runnables and exceptionholder as member.
     private HashMap _callexecutions;
     private HashMap _updateexecutions;
 
     /***
        Constructor.
        @param servicestub The service stub to contact the server.
      */
     public SwingClientDelegateExt(IStructureService servicestub) {
 	_servicestub = servicestub;
 	_callexecutions = new HashMap();
 	_updateexecutions = new HashMap();
     }
 
     private CallExecution getCallExecution(IClientRootObject structure) {
 	CallExecution exe = (CallExecution)_callexecutions.get(structure);
 	if (exe == null) {
 	    exe = new CallExecution(this, structure);
 	    _callexecutions.put(structure, exe);
 	}
 	return exe;
     }
 
     private UpdateExecution getUpdateExecution(IClientRootObject structure) {
 	UpdateExecution exe = (UpdateExecution)_updateexecutions.get(structure);
 	if (exe == null) {
 	    exe = new UpdateExecution(this, structure);
 	    _updateexecutions.put(structure, exe);
 	}
 	return exe;
     }
 
     public Object execute(IMethodCall call) throws MethodCallException, IllegalModificationException, IncompatibleVersionsException {
 	IClientRootObject structure = (IClientRootObject)call.getTarget();
 	IMethodCallEncoder encoder = Protocol.getMethodCallEncoder();
 	String enc = null;
 	Object ret = null;	
 	IStructureTask tasks[] = null;
 
 	synchronized(structure.getStructureLock()) {	    
 	    try {
 		enc = encoder.encode(call);
 	    } catch (IOException x) {
 		IllegalModificationException ix = new IllegalModificationException("Could not encode method call.");
 		ix.initCause(x);
 		throw ix;
 	    }
 	    try {
 		commit(structure, enc);
 	    } catch (RemoteException x) {
 		IllegalModificationException ix = new IllegalModificationException("Could not commit changes. Exception on server-side.");
 		ix.initCause(x);
 		throw ix;		
 	    }
 	    
 	    CallExecution exe = getCallExecution(structure);
 	    exe.setCall(call);
 
 	    // FIXME: This causes a deadlock if another MethodCall is nested inside this MethodCall
 	    // (e.g. GenericProperties.put() is mapped to Property.setValue())
 	    // FIXME!!!!
 	    SwingThread.invokeAndWaitSilently(exe);
 
 	    if (exe.exceptionOccured()) {
 		throw new MethodCallException("Could not invoke method call. Structure invalid and needs to be checked out again.", exe.getException());
 	    }
 
 	    ret = exe.getReturnValue();
 
 	    List queue = structure.getTaskQueue();
 	    tasks = (IStructureTask[])queue.toArray(new IStructureTask[queue.size()]);
 	    queue.clear();
 	}
 
 	try {
 	    for (int i=0; i<tasks.length; i++) {
 		tasks[i].run();
 	    }
 	} catch (IncompatibleVersionsException x) {
 	    IncompatibleVersionsException ix = new IncompatibleVersionsException("Nested IncompatibleVersionsException.", x);
 	    throw ix;
 	} catch (IllegalModificationException x) {
 	    IllegalModificationException ix = new IllegalModificationException("Nested IllegalModificationException.", x);
 	    throw ix;
 	} catch (Exception x) {
 	    throw new MethodCallException("Could not execute inner method call.", x);
 	}
 
 	return ret;
     }
 
     public void commit(IClientRootObject structure, String modification) throws IllegalModificationException, IncompatibleVersionsException, RemoteException {
        synchronized (structure.getStructureLock()) {
            int newversion = _servicestub.commitModification(structure.getID(), structure.getVersionNumber(), modification);
 	   structure.setVersionNumber(newversion);
        }
     }
     
     public void update(IClientRootObject structure) throws IllegalModificationException, RemoteException {
 	IStructureTask tasks[] = null;
 		
 	synchronized (structure.getStructureLock()) {
 	    /// VERSION, COMMAND, CONTENT
 	    String[][] updates = _servicestub.getModificationsForUpdate(structure.getID(), structure.getVersionNumber());
 	    
 	    if (updates.length > 0) {
 		
 		UpdateExecution exe = getUpdateExecution(structure);
 		exe.setUpdates(updates);
 		SwingThread.invokeAndWaitSilently(exe);
 		
 		if (exe.exceptionOccured()) {
 		    throw (IllegalModificationException)exe.getException();
 		}
 		
 		List queue = structure.getTaskQueue();
 		tasks = (IStructureTask[])queue.toArray(new IStructureTask[queue.size()]);
 		queue.clear();
 	    }
 	}   
 
 	try {
 	    for (int i=0; tasks!=null && i<tasks.length; i++) {
 		tasks[i].run();
 	    }
 	} catch (IncompatibleVersionsException x) {
 	    IllegalModificationException ix = new IllegalModificationException("Nested IncompatibleVersionsException.", x);
 	    throw ix;
 	} catch (IllegalModificationException x) {
 	    IllegalModificationException ix = new IllegalModificationException("Nested IllegalModificationException.", x);
 	    throw ix;
 	} catch (Exception x) {
 	    IllegalModificationException ix = new IllegalModificationException("Nested Exception during inner method call.", x);
 	    throw ix;
 	}
     }
 
     protected void handleUpdate(IClientRootObject structure, String command, String content) throws IllegalModificationException {
 	if (Protocol.IDENTIFIER_FULLUPDATE.equals(command)) {
 	    if (logger.isDebugEnabled()) 
 		logger.debug("Performing full update.\n"+content);
 
 	    try {
 		((ProtocolWorkflow)structure).__fromXML(content);
 	    } catch (WorkflowFormatException x) {
 		throw new IllegalModificationException("Could not parse workflow description.", x);
 	    } catch (CapacityException x) {
 		throw new IllegalModificationException("Could not parse workflow description.", x);
 	    }
 	} else if (Protocol.IDENTIFIER_MODIFICATION.equals(command))  {
 	    if (logger.isDebugEnabled()) 
 		logger.debug("Performing update.\n"+content);
 
 	    Protocol.getModificationHandler().handleModification(structure, content);
 	} else {
 	    throw new IllegalModificationException("Unknown update command: "+command);
 	}	
     }
 }