/**
 * 
 */
package org.gcube.portlets.user.td.sdmxexportwidget.client.progress;

import java.util.ArrayList;

import org.gcube.portlets.user.td.gwtservice.client.rpc.TDGWTServiceAsync;
import org.gcube.portlets.user.td.gwtservice.shared.sdmx.SDMXExportMonitor;
import org.gcube.portlets.user.td.widgetcommonevent.shared.TRId;

import com.allen_sauer.gwt.log.client.Log;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.rpc.AsyncCallback;

/**
 * 
 * @author "Giancarlo Panichi" 
 * <a href="mailto:g.panichi@isti.cnr.it">g.panichi@isti.cnr.it</a> 
 *
 */

public class SDMXExportProgressUpdater extends Timer {

	protected ArrayList<SDMXExportProgressListener> listeners = new ArrayList<SDMXExportProgressListener>();

	/**
	 * {@inheritDoc}
	 */
	@Override
	public void run() {
		Log.debug("requesting operation progress");
		TDGWTServiceAsync.INSTANCE
				.getSDMXExportMonitor(new AsyncCallback<SDMXExportMonitor>() {

				
					public void onFailure(Throwable caught) {
						cancel();
						Log.error("Error retrieving the operation state",
								caught);
						String message = getStack(caught);
						fireOperationFailed(caught,
								"Failed getting operation updates", message);
					}

					public void onSuccess(SDMXExportMonitor result) {
						Log.info("retrieved SDMXImportMonitor: "
								+ result.getStatus());
						switch (result.getStatus()) {
						case INITIALIZING:
							Log.info("SDMX Export Initializing...");
							fireOperationInitializing();
							break;
						case ABORTED:
							cancel();
							Log.info("SDMX Export Operation Aborted");
							break;
						case IN_PROGRESS:
							fireOperationUpdate(result.getProgress());
							break;
						case VALIDATING_RULES:
							fireOperationValidate(result.getProgress());
							break;	
						case GENERATING_VIEW:
							Log.info("Generating View...");
							fireOperationGeneratingView();
							break;	
						case FAILED:
							cancel();
							errorMessage(result);
							break;
						case STOPPED:
							cancel();
							stopMessage(result);
							break;	
						case SUCCEDED:
							cancel();
							Log.info("Export fisnish");
							fireOperationComplete();
							break;

						default:
							Log.info("Unknow State");
							break;
						}

					}

				});

	}

	protected void errorMessage(SDMXExportMonitor result) {
		Log.info("SDMX Export Failed");
		Throwable th = null;
		String failure = null;
		String details = null;
		if (result.getError() != null) {
			th = result.getError();
			failure = "Failed Client Library Export";
			details = result.getError().getLocalizedMessage();
		} else {
			th = new Throwable("Failed");
			failure = "Failed Client Library Export";
			details = "Error in export";
		}
		fireOperationFailed(th, failure, details);
	}

	protected void stopMessage(SDMXExportMonitor result) {
		Log.info("SDMX Export Stopped");
		String failure = null;
		String details = null;
		if (result.getError() != null) {	
			failure = "Stopped";
			details = result.getError().getLocalizedMessage();
		} else {
			failure = "Stopped";
			details = "Stopped export SDMX";
		}
	
		fireOperationStopped(result.getTrId(),failure, details);
	}
	
	protected String getStack(Throwable e) {
		String message = e.getLocalizedMessage() + " -> <br>";
		Throwable c = e.getCause();
		if (c != null)
			message += getStack(c);
		return message;
	}

	protected void fireOperationInitializing() {
		for (SDMXExportProgressListener listener : listeners)
			listener.operationInitializing();
	}
	
	protected void fireOperationGeneratingView() {
		for (SDMXExportProgressListener listener : listeners)
			listener.operationGeneratingView();
	}

	
	protected void fireOperationUpdate(float elaborated) {
		for (SDMXExportProgressListener listener : listeners)
			listener.operationUpdate(elaborated);
	}
	
	protected void fireOperationValidate(float elaborated) {
		for (SDMXExportProgressListener listener : listeners)
			listener.operationValidate(elaborated);
	}

	protected void fireOperationComplete() {
		for (SDMXExportProgressListener listener : listeners)
			listener.operationComplete();
	}

	protected void fireOperationFailed(Throwable caught, String failure,
			String failureDetails) {
		for (SDMXExportProgressListener listener : listeners)
			listener.operationFailed(caught, failure, failureDetails);
	}
	
	protected void fireOperationStopped(TRId trId, String reason, String details) {
		for (SDMXExportProgressListener listener : listeners)
			listener.operationStopped(trId,reason, details);
	}

	/**
	 * Add a new {@link SDMXExportProgressListener} to this
	 * {@link SDMXExportProgressUpdater}.
	 * 
	 * @param listener
	 *            the listener to add.
	 */
	public void addListener(SDMXExportProgressListener listener) {
		listeners.add(listener);
	}

	/**
	 * Removes the specified {@link SDMXExportProgressListener} from this
	 * {@link SDMXExportProgressUpdater}.
	 * 
	 * @param listener
	 *            the listener to remove.
	 */
	public void removeListener(SDMXExportProgressListener listener) {
		listeners.remove(listener);
	}
}