/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

* Deletes multiple traces

*

*/

package com.nokia.tracebuilder.engine.propertydialog;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import com.nokia.tracebuilder.engine.CheckListDialogEntry;

import com.nokia.tracebuilder.engine.LocationProperties;

import com.nokia.tracebuilder.engine.TraceBuilderDialogs;

import com.nokia.tracebuilder.engine.TraceBuilderGlobals;

import com.nokia.tracebuilder.engine.TraceLocationList;

import com.nokia.tracebuilder.engine.TraceBuilderDialogs.CheckListDialogParameters;

import com.nokia.tracebuilder.engine.TraceBuilderDialogs.CheckListDialogType;

import com.nokia.tracebuilder.engine.TraceBuilderDialogs.QueryDialogParameters;

import com.nokia.tracebuilder.engine.TraceBuilderErrorCodes.TraceBuilderErrorCode;

import com.nokia.tracebuilder.engine.source.SourceEngine;

import com.nokia.tracebuilder.engine.source.SourceProperties;

import com.nokia.tracebuilder.model.Trace;

import com.nokia.tracebuilder.model.TraceBuilderException;

import com.nokia.tracebuilder.model.TraceGroup;

import com.nokia.tracebuilder.model.TraceModel;

import com.nokia.tracebuilder.model.TraceObject;

/**

 * Deletes multiple traces

 * 

 */

public final class DeleteMultipleTracesCallback extends

		DeleteTraceFromSourceCallback {

	/**

	 * Instrumentation engine contains sets of instrumented traces

	 */

	private InstrumentationEngine instrumentationEngine;

	/**

	 * Trace model

	 */

	private TraceModel model;

	/**

	 * Constructor

	 * 

	 * @param model

	 *            trace model

	 * @param sourceEngine

	 *            source engine

	 * @param instrumentationEngine

	 *            instrumentation engine

	 */

	public DeleteMultipleTracesCallback(TraceModel model,

			SourceEngine sourceEngine,

			InstrumentationEngine instrumentationEngine) {

		super(model, sourceEngine);

		this.model = model;

		this.instrumentationEngine = instrumentationEngine;

	}

	/**

	 * Shows the delete dialog

	 * 

	 * @return the dialog result

	 * @throws TraceBuilderException

	 *             if traces cannot be deleted

	 */

	@Override

	public int delete() throws TraceBuilderException {

		int retval;

		ArrayList<Trace> traces = new ArrayList<Trace>();

		showDialog(traces);

		if (traces.size() > 0) {

			model.startProcessing();

			try {

				for (int i = 0; i < traces.size(); i++) {

					deleteTrace(traces.get(i));

				}

			} finally {

				model.processingComplete();

			}

			retval = TraceBuilderDialogs.OK;

		} else {

			retval = TraceBuilderDialogs.CANCEL;

		}

		return retval;

	}

	/**

	 * Deletes a trace

	 * 

	 * @param trace

	 *            the trace to be deleted

	 */

	private void deleteTrace(Trace trace) {

		removeTraceFromSource(trace);

		trace.getGroup().removeTrace(trace);

	}

	/**

	 * Shows the dialog

	 * 

	 * @param traces

	 *            the list for traces to be removed

	 * @throws TraceBuilderException

	 *             if processing fails

	 */

	private void showDialog(List<Trace> traces) throws TraceBuilderException {

		List<CheckListDialogEntry> rootEntries = null;

		CheckListDialogEntry groups = createGroups();

		CheckListDialogEntry instrumentations = createInstrumentations(groups);

		if (instrumentations.hasChildren()) {

			rootEntries = new ArrayList<CheckListDialogEntry>();

			rootEntries.add(instrumentations);

			rootEntries.add(groups);

		} else if (groups.hasChildren()) {

			rootEntries = new ArrayList<CheckListDialogEntry>();

			rootEntries.add(groups);

		}

		if (rootEntries != null) {

			CheckListDialogParameters parameters = buildParameters(instrumentations

					.hasChildren());

			parameters.rootItems = rootEntries;

			parameters.dialogType = CheckListDialogType.DELETE_TRACES;

			int ret = TraceBuilderGlobals.getDialogs()

					.showCheckList(parameters);

			if (ret == TraceBuilderDialogs.OK) {

				// Deletes the checked traces

				for (CheckListDialogEntry entry : rootEntries) {

					addToList(entry, traces);

				}

			}

		} else {

			throw new TraceBuilderException(

					TraceBuilderErrorCode.NO_TRACES_TO_DELETE);

		}

	}

	/**

	 * Builds the parameter list

	 * 

	 * @param hasInstrumentation

	 *            true if there are instrumentation entries

	 * @return the list

	 */

	private CheckListDialogParameters buildParameters(boolean hasInstrumentation) {

		CheckListDialogParameters parameters = new CheckListDialogParameters();

		parameters.expandLevel = 0;

		parameters.showRoot = hasInstrumentation;

		return parameters;

	}

	/**

	 * Creates instrumentations list

	 * 

	 * @param groupRoot

	 *            the root of groups list

	 * @return the root entry for instrumentations

	 */

	private CheckListDialogEntry createInstrumentations(

			CheckListDialogEntry groupRoot) {

		Iterator<String> instrumentations = instrumentationEngine

				.getInstrumenterIDs();

		CheckListDialogEntry instrumenterRoot = new CheckListDialogEntry();

		instrumenterRoot.setObject("Traces from instrumentations"); //$NON-NLS-1$

		while (instrumentations.hasNext()) {

			String instrumenterID = instrumentations.next();

			addInstrumentation(instrumenterRoot, instrumenterID, groupRoot);

		}

		return instrumenterRoot;

	}

	/**

	 * Adds traces from given instrumentation to the list

	 * 

	 * @param entry

	 *            the root entry for instrumentations

	 * @param instrumenterID

	 *            the instrumenter ID

	 * @param groupRoot

	 *            the root of groups list

	 */

	private void addInstrumentation(CheckListDialogEntry entry,

			String instrumenterID, CheckListDialogEntry groupRoot) {

		Iterator<InstrumentedTraceRule> instrumentedTraces = instrumentationEngine

				.getInstrumentedTraces(instrumenterID);

		CheckListDialogEntry instrumenterEntry = new CheckListDialogEntry();

		instrumenterEntry.setObject(instrumenterID);

		while (instrumentedTraces.hasNext()) {

			Trace trace = (Trace) instrumentedTraces.next().getOwner();

			addTrace(instrumenterEntry, trace);

		}

		if (instrumenterEntry.hasChildren()) {

			entry.addChild(instrumenterEntry);

		}

	}

	/**

	 * Adds a trace to given entry

	 * 

	 * @param entry

	 *            the root entry

	 * @param trace

	 *            the trace

	 * @return the trace entry

	 */

	private CheckListDialogEntry addTrace(CheckListDialogEntry entry,

			Trace trace) {

		CheckListDialogEntry traceEntry = new CheckListDialogEntry();

		TraceLocationList list = trace.getExtension(TraceLocationList.class);

		if (list != null) {

			for (LocationProperties loc : list) {

				String traceLocationFileName = loc.getFileName();

				Iterator<SourceProperties> sources = TraceBuilderGlobals

						.getTraceBuilder().getOpenSources();

				while (sources.hasNext()) {

					SourceProperties source = sources.next();

					if (traceLocationFileName.equals(source.getFileName())) {

						traceEntry.setObject(trace);

						entry.addChild(traceEntry);

						break;

					}

				}

			}

		}

		return traceEntry;

	}

	/**

	 * Adds groups to the list

	 * 

	 * @return the root of group entries

	 */

	private CheckListDialogEntry createGroups() {

		CheckListDialogEntry groupRoot = new CheckListDialogEntry();

		groupRoot.setObject("Traces from groups"); //$NON-NLS-1$

		for (TraceGroup group : model) {

			addGroup(groupRoot, group);

		}

		return groupRoot;

	}

	/**

	 * Adds a group to the list

	 * 

	 * @param rootEntry

	 *            the root entry

	 * @param group

	 *            the group

	 */

	private void addGroup(CheckListDialogEntry rootEntry, TraceGroup group) {

		CheckListDialogEntry groupEntry = new CheckListDialogEntry();

		groupEntry.setObject(group);

		for (Trace trace : group) {

			addTrace(groupEntry, trace);

		}

		if (groupEntry.hasChildren()) {

			rootEntry.addChild(groupEntry);

		}

	}

	/**

	 * Recursively adds children of given entry to the list of traces to be

	 * removed

	 * 

	 * @param entry

	 *            an entry

	 * @param traces

	 *            the list of traces

	 */

	private void addToList(CheckListDialogEntry entry, List<Trace> traces) {

		if (entry.isChecked() && entry.getObject() instanceof Trace) {

			traces.add((Trace) entry.getObject());

		}

		for (CheckListDialogEntry child : entry) {

			addToList(child, traces);

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.tracebuilder.engine.propertydialog.DeleteObjectCallback#

	 *      buildQuery(com.nokia.tracebuilder.model.TraceObject)

	 */

	@Override

	protected QueryDialogParameters buildQuery(TraceObject object)

			throws TraceBuilderException {

		// Not used, this class overrides the delete method

		return null;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.tracebuilder.engine.propertydialog.DeleteObjectCallback#

	 *      deleteObject(com.nokia.tracebuilder.model.TraceObject,

	 *      com.nokia.tracebuilder.engine.TraceBuilderDialogs.QueryDialogParameters)

	 */

	@Override

	protected void deleteObject(TraceObject object,

			QueryDialogParameters queryResults) {

		// Not used, this class overrides the delete method

	}

}