/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation, See4sys and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     See4sys - copied from org.eclipse.ui.views.markers.internal.ProblemView to
 *               add support for problem markers on model objects (rather than
 *               only on workspace resources)
 *	   Elektrobit - [572591]  Make MarkerResolutionDialog extensible
 *******************************************************************************/
package org.eclipse.sphinx.emf.validation.ui.views;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.commands.ActionHandler;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.ColumnLayoutData;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.TableLayout;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.osgi.util.NLS;
import org.eclipse.sphinx.emf.validation.markers.IValidationMarker;
import org.eclipse.sphinx.emf.validation.ui.SphinxValidationUiActivator;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.XMLMemento;
import org.eclipse.ui.activities.ActivityManagerEvent;
import org.eclipse.ui.activities.IActivityManagerListener;
import org.eclipse.ui.handlers.IHandlerActivation;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.internal.ide.IDEInternalPreferences;
import org.eclipse.ui.progress.IWorkbenchSiteProgressService;

import com.ibm.icu.text.MessageFormat;

/**
 * The Validation view is the view that displays problem markers on model objects.
 * <p>
 * Unfortunately, there was no other choice than copying the whole code from ProblemView for that purpose because most
 * of the relevant methods and fields of the latter are private or package private.
 * </p>
 */
public class ValidationView extends MarkerView {

	private final static String[] ROOT_TYPES = { IValidationMarker.MODEL_VALIDATION_PROBLEM, IMarker.PROBLEM };

	private final static String TAG_DIALOG_SECTION = "org.eclipse.sphinx.emf.validation.ui"; //$NON-NLS-1$

	private static final String TAG_SYSTEM_FILTER_ENTRY = "systemFilter";//$NON-NLS-1$

	private ActionResolveMarker resolveMarkerAction;

	private IHandlerService handlerService;

	private IHandlerActivation resolveMarkerHandlerActivation;

	private IActivityManagerListener activityManagerListener;

	private IField severityAndMessage = new FieldSeverityAndMessage();

	private IField eObject = new FieldEObject();

	private IField eObjectURI = new FieldEObjectURI();

	private IField eObjectType = new FieldEObjectType();

	private IField resource = new FieldResource();

	private IField ruleId = new FieldRuleId();

	private IField creationTime = new FieldCreationTime();

	// Add the marker ID so the table sorter won't reduce
	// errors on the same line bug 82502
	private static IField id = new FieldId();

	private class GroupingAction extends Action {

		IField groupingField;

		ValidationView problemView;

		/**
		 * Create a new instance of the receiver.
		 *
		 * @param label
		 * @param field
		 * @param view
		 */
		public GroupingAction(String label, IField field, ValidationView view) {
			super(label, IAction.AS_RADIO_BUTTON);

			groupingField = field;
			problemView = view;
			IField categoryField = view.getMarkerAdapter().getCategorySorter().getCategoryField();
			if (categoryField == null) {
				setChecked(groupingField == null);
			} else {
				boolean state = categoryField.equals(groupingField);
				if (groupingField != null) {
					state |= categoryField.getDescription().equals(groupingField.getDescription());
				}
				setChecked(state);
			}
		}

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.action.Action#run()
		 */
		@Override
		public void run() {

			if (isChecked()) {
				Job categoryJob = new Job(MarkerMessages.ProblemView_UpdateCategoryJob) {
					/*
					 * (non-Javadoc)
					 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
					 */
					@Override
					protected IStatus run(IProgressMonitor monitor) {
						try {
							markerProcessJob.join();
						} catch (InterruptedException e) {
							return Status.CANCEL_STATUS;
						}
						problemView.selectCategoryField(groupingField, problemView.getMarkerAdapter().getCategorySorter());

						getMarkerAdapter().getCategorySorter().saveState(getDialogSettings());
						return Status.OK_STATUS;
					}
				};
				categoryJob.setSystem(true);
				problemView.preserveSelection();

				IWorkbenchSiteProgressService progressService = getProgressService();
				if (progressService == null) {
					categoryJob.schedule();
				} else {
					getProgressService().schedule(categoryJob);
				}

			}

		}
	}

	/**
	 * Return a new instance of the receiver.
	 */
	public ValidationView() {
		super();
		creationTime.setShowing(true);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#dispose()
	 */
	@Override
	public void dispose() {
		if (resolveMarkerAction != null) {
			resolveMarkerAction.dispose();
		}
		if (resolveMarkerHandlerActivation != null && handlerService != null) {
			handlerService.deactivateHandler(resolveMarkerHandlerActivation);
		}

		PlatformUI.getWorkbench().getActivitySupport().getActivityManager().removeActivityManagerListener(activityManagerListener);
		super.dispose();
	}

	// /*
	// * @see org.eclipse.sphinx.emf.validation.ui.views.MarkerView#getAdapter(java.lang.Class)
	// */
	// @Override
	// public Object getAdapter(Class adaptable) {
	// if (adaptable.equals(IShowInSource.class)) {
	// return new IShowInSource() {
	// @Override
	// public ShowInContext getShowInContext() {
	// ISelection selection = getViewer().getSelection();
	// if (!(selection instanceof IStructuredSelection)) {
	// return null;
	// }
	// IStructuredSelection structured = (IStructuredSelection) selection;
	// Iterator markerIterator = structured.iterator();
	// List newSelection = new ArrayList();
	// List selectedMarkers = new ArrayList();
	// while (markerIterator.hasNext()) {
	// Object obj = markerIterator.next();
	// if (obj instanceof ConcreteMarker) {
	// ConcreteMarker element = (ConcreteMarker) obj;
	// newSelection.add(element.getResource());
	// selectedMarkers.add(element.getMarker());
	// }
	// }
	// return new ShowInContext(new StructuredSelection(selectedMarkers), new StructuredSelection(newSelection));
	// }
	//
	// };
	// }
	// return super.getAdapter(adaptable);
	// }

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.TableView#getSortingFields()
	 */
	@Override
	protected IField[] getSortingFields() {
		return new IField[] { severityAndMessage, eObject, eObjectURI, resource, eObjectType, ruleId, creationTime,
				// Add the marker ID so the table sorter won't reduce
				// errors on the same line bug 82502
				id };
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.TableView#getDialogSettings()
	 */
	@Override
	protected IDialogSettings getDialogSettings() {
		IDialogSettings workbenchSettings = SphinxValidationUiActivator.getDefault().getDialogSettings();
		IDialogSettings settings = workbenchSettings.getSection(TAG_DIALOG_SECTION);

		if (settings == null) {
			settings = workbenchSettings.addNewSection(TAG_DIALOG_SECTION);
		}

		return settings;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.TableView#createActions()
	 */
	@Override
	protected void createActions() {
		super.createActions();
		propertiesAction = new ActionProblemProperties(this, getViewer());
		resolveMarkerAction = createActionResolveMarker(this, getViewer());
	}

	/**
	 * @param markerView
	 * @param provider
	 * @return the resolve marker action
	 */
	protected ActionResolveMarker createActionResolveMarker(MarkerView markerView, ISelectionProvider provider) {
		return new ActionResolveMarker(markerView, provider);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.internal.tableview.TableView#registerGlobalActions(org.eclipse.ui.IActionBars)
	 */
	@Override
	protected void registerGlobalActions(IActionBars actionBars) {
		super.registerGlobalActions(actionBars);

		String quickFixId = "org.eclipse.jdt.ui.edit.text.java.correction.assist.proposals"; //$NON-NLS-1$
		resolveMarkerAction.setActionDefinitionId(quickFixId);

		handlerService = (IHandlerService) getViewSite().getService(IHandlerService.class);
		if (handlerService != null) {
			resolveMarkerHandlerActivation = handlerService.activateHandler(quickFixId, new ActionHandler(resolveMarkerAction));
		}
	}

	/*
	 * (non-Javadoc)
	 * @see
	 * org.eclipse.ui.views.markers.internal.MarkerView#fillContextMenuAdditions(org.eclipse.jface.action.IMenuManager)
	 */
	@Override
	protected void fillContextMenuAdditions(IMenuManager manager) {
		manager.add(new Separator());
		manager.add(resolveMarkerAction);
	}

	@Override
	protected String[] getRootTypes() {
		return ROOT_TYPES;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.TableView#getAllFields()
	 */
	@Override
	protected IField[] getAllFields() {

		// Add the marker ID so the table sorter won't reduce
		// errors on the same line bug 82502
		return new IField[] { severityAndMessage, eObject, eObjectURI, resource, eObjectType, ruleId, creationTime };
	}

	@Override
	void updateTitle() {
		MarkerList visibleMarkers = getVisibleMarkers();
		String breakdown = formatSummaryBreakDown(visibleMarkers);
		int filteredCount = visibleMarkers.getItemCount();
		int totalCount = getTotalMarkers();
		if (filteredCount != totalCount) {
			breakdown = NLS.bind(MarkerMessages.problem_filter_matchedMessage, new Object[] { breakdown, new Integer(filteredCount),
					new Integer(totalCount) });
		}
		setContentDescription(breakdown);
	}

	private String formatSummaryBreakDown(MarkerList visibleMarkers) {
		return MessageFormat.format(MarkerMessages.problem_statusSummaryBreakdown, new Object[] { new Integer(visibleMarkers.getErrors()),
				new Integer(visibleMarkers.getWarnings()), new Integer(visibleMarkers.getInfos()) });
	}

	private String getSummary(MarkerList markers) {
		String message = MessageFormat.format(MarkerMessages.marker_statusSummarySelected, new Object[] { new Integer(markers.getItemCount()),
				formatSummaryBreakDown(markers) });
		return message;
	}

	/**
	 * Retrieves statistical information (the total number of markers with each severity type) for the markers contained
	 * in the selection passed in. This information is then massaged into a string which may be displayed by the caller.
	 *
	 * @param selection
	 *            a valid selection or <code>null</code>
	 * @return a message ready for display
	 */
	@Override
	protected String updateSummarySelected(IStructuredSelection selection) {
		Collection selectionList;

		selectionList = new ArrayList();
		Iterator selectionIterator = selection.iterator();
		while (selectionIterator.hasNext()) {
			MarkerNode next = (MarkerNode) selectionIterator.next();
			if (next.isConcrete()) {
				selectionList.add(next);
			}
		}

		return getSummary(new MarkerList(selectionList));
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#getMarkerTypes()
	 */
	@Override
	protected String[] getMarkerTypes() {
		return new String[] { IMarker.PROBLEM };
	}

	@Override
	protected String getStaticContextId() {
		return PlatformUI.PLUGIN_ID + ".problem_view_context";//$NON-NLS-1$
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#createFiltersDialog()
	 */
	@Override
	protected DialogMarkerFilter createFiltersDialog() {

		MarkerFilter[] filters = getUserFilters();
		ProblemFilter[] problemFilters = new ProblemFilter[filters.length];
		System.arraycopy(filters, 0, problemFilters, 0, filters.length);
		return new DialogProblemFilter(getSite().getShell(), problemFilters);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#createFilter(java.lang.String)
	 */
	@Override
	protected MarkerFilter createFilter(String name) {
		return new ProblemFilter(name);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#getSectionTag()
	 */
	@Override
	protected String getSectionTag() {
		return TAG_DIALOG_SECTION;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#getMarkerEnablementPreferenceName()
	 */
	@Override
	String getMarkerEnablementPreferenceName() {
		return IDEInternalPreferences.LIMIT_PROBLEMS;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#getMarkerLimitPreferenceName()
	 */
	@Override
	String getMarkerLimitPreferenceName() {
		return IDEInternalPreferences.PROBLEMS_LIMIT;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#getFiltersPreferenceName()
	 */
	@Override
	String getFiltersPreferenceName() {
		return IDEInternalPreferences.PROBLEMS_FILTERS;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#getAllFilters()
	 */
	@Override
	MarkerFilter[] getAllFilters() {
		MarkerFilter[] userFilters = super.getAllFilters();
		Collection declaredFilters = MarkerSupportRegistry.getInstance().getRegisteredFilters();
		Iterator iterator = declaredFilters.iterator();

		MarkerFilter[] allFilters = new MarkerFilter[userFilters.length + declaredFilters.size()];
		System.arraycopy(userFilters, 0, allFilters, 0, userFilters.length);
		int index = userFilters.length;

		while (iterator.hasNext()) {
			allFilters[index] = (MarkerFilter) iterator.next();
			index++;
		}
		return allFilters;

	}

	/*
	 * (non-Javadoc)
	 * @see
	 * org.eclipse.ui.views.markers.internal.MarkerView#addDropDownContributions(org.eclipse.jface.action.IMenuManager)
	 */
	@Override
	void addDropDownContributions(IMenuManager menu) {

		MenuManager groupByMenu = new MenuManager(MarkerMessages.ProblemView_GroupByMenu);
		groupByMenu.add(new GroupingAction(MarkerMessages.ProblemView_EObject, new FieldEObject(), this));
		groupByMenu.add(new GroupingAction(MarkerMessages.ProblemView_EObjectType, new FieldEObjectType(), this));
		groupByMenu.add(new GroupingAction(MarkerMessages.ProblemView_Type, new FieldCategory(), this));
		groupByMenu.add(new GroupingAction(MarkerMessages.ProblemView_RuleId, new FieldRuleId(), this));

		Iterator definedGroups = MarkerSupportRegistry.getInstance().getMarkerGroups().iterator();
		while (definedGroups.hasNext()) {
			Object o = definedGroups.next();
			if (o instanceof FieldMarkerGroup) {
				FieldMarkerGroup group = (FieldMarkerGroup) o;
				if (group.getId().equals("org.eclipse.ui.ide.severity")) {
					groupByMenu.add(new GroupingAction(group.getDescription(), group, this));
				}
			}
		}

		groupByMenu.add(new GroupingAction(MarkerMessages.ProblemView_None, null, this));
		menu.add(groupByMenu);

		super.addDropDownContributions(menu);
	}

	/**
	 * Resize the category column in the table.
	 */
	protected void regenerateLayout() {
		TableLayout layout = new TableLayout();
		getViewer().getTree().setLayout(layout);

		ColumnLayoutData[] columnWidths = getDefaultColumnLayouts();
		for (ColumnLayoutData element : columnWidths) {
			layout.addColumnData(element);

		}
		getViewer().getTree().layout(true);

	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.TableView#setSorter(org.eclipse.ui.views.markers.internal.TableSorter)
	 */
	@Override
	void setComparator(TableComparator sorter2) {
		getMarkerAdapter().getCategorySorter().setTableSorter(sorter2);
		getMarkerAdapter().getCategorySorter().saveState(getDialogSettings());
		updateForNewComparator(sorter2);

	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#getTableSorter()
	 */
	@Override
	public TableComparator getTableSorter() {
		return ((CategoryComparator) getViewer().getComparator()).innerSorter;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#createPartControl(org.eclipse.swt.widgets.Composite)
	 */
	@Override
	public void createPartControl(Composite parent) {
		super.createPartControl(parent);
		createActivityManagerListener();
		PlatformUI.getWorkbench().getActivitySupport().getActivityManager().addActivityManagerListener(activityManagerListener);
	}

	/**
	 * Create a new listener for activity changes.
	 */
	private void createActivityManagerListener() {
		activityManagerListener = new IActivityManagerListener() {
			/*
			 * (non-Javadoc)
			 * @seeorg.eclipse.ui.activities.IActivityManagerListener#activityManagerChanged(org.eclipse.ui.activities.
			 * ActivityManagerEvent)
			 */
			@Override
			public void activityManagerChanged(ActivityManagerEvent activityManagerEvent) {
				clearEnabledFilters();
				refreshViewer();
			}
		};

	}

	/**
	 * Return the field whose description matches description.
	 *
	 * @param description
	 * @return IField
	 */
	public IField findField(String description) {
		IField[] fields = getSortingFields();
		for (IField element : fields) {
			if (element.getDescription().equals(description)) {
				return element;
			}
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.TableView#buildComparator()
	 */
	@Override
	protected ViewerComparator buildComparator() {

		TableComparator sorter = createTableComparator();
		CategoryComparator category = new CategoryComparator(sorter);
		category.restoreState(getDialogSettings(), this);
		return category;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#canBeEditable()
	 */
	@Override
	boolean canBeEditable() {
		return false;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#initToolBar(org.eclipse.jface.action.IToolBarManager)
	 */
	@Override
	protected void initToolBar(IToolBarManager tbm) {
		tbm.add(getFilterAction());
		tbm.update(false);
	}

	/**
	 * Select the category for the receiver.
	 *
	 * @param description
	 * @param sorter
	 *            - the sorter to select for
	 */
	public void selectCategory(String description, CategoryComparator sorter) {

		if (description == null) {
			selectCategoryField(null, sorter);
		}

		if (description.equals(MarkerMessages.description_eObject)) {
			selectCategoryField(new FieldEObject(), sorter);
			return;
		} else if (description.equals(MarkerMessages.description_eObjectType)) {
			selectCategoryField(new FieldEObjectType(), sorter);
			return;
		} else if (description.equals(MarkerMessages.description_type)) {
			selectCategoryField(new FieldCategory(), sorter);
			return;
		} else if (description.equals(MarkerMessages.description_ruleId)) {
			selectCategoryField(new FieldRuleId(), sorter);
			return;
		}

		Iterator definedGroups = MarkerSupportRegistry.getInstance().getMarkerGroups().iterator();
		while (definedGroups.hasNext()) {
			// FieldMarkerGroup group = (FieldMarkerGroup) definedGroups.next();
			IField group = (IField) definedGroups.next();
			if (group.getDescription().equals(description)) {
				selectCategoryField(group, sorter);
				return;
			}
		}
		selectCategoryField(null, sorter);

	}

	/**
	 * Select the field groupingField.
	 *
	 * @param groupingField
	 * @param sorter
	 */
	void selectCategoryField(IField groupingField, CategoryComparator sorter) {
		sorter.setCategoryField(groupingField);

		// Do not refresh if the input has not been set yet
		if (getMarkerAdapter() != null) {
			getMarkerAdapter().getCurrentMarkers().clearGroups();
			refreshViewer();
		}
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#writeFiltersSettings(org.eclipse.ui.XMLMemento)
	 */
	@Override
	protected void writeFiltersSettings(XMLMemento memento) {
		super.writeFiltersSettings(memento);

		// Add the system filters
		Iterator filters = MarkerSupportRegistry.getInstance().getRegisteredFilters().iterator();

		while (filters.hasNext()) {
			MarkerFilter filter = (MarkerFilter) filters.next();
			IMemento child = memento.createChild(TAG_SYSTEM_FILTER_ENTRY, filter.getName());
			child.putString(MarkerFilter.TAG_ENABLED, String.valueOf(filter.isEnabled()));
		}

	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#restoreFilters(org.eclipse.ui.IMemento)
	 */
	@Override
	void restoreFilters(IMemento memento) {

		super.restoreFilters(memento);

		if (memento == null) {
			return;
		}

		IMemento[] sections = memento.getChildren(TAG_SYSTEM_FILTER_ENTRY);

		Collection registered = MarkerSupportRegistry.getInstance().getRegisteredFilters();
		MarkerFilter[] filters = new MarkerFilter[registered.size()];
		registered.toArray(filters);

		if (sections != null) {

			for (IMemento element : sections) {
				String filterName = element.getID();
				boolean enabled = Boolean.valueOf(element.getString(MarkerFilter.TAG_ENABLED)).booleanValue();
				setEnablement(filterName, enabled, filters);

			}
		}

	}

	/**
	 * Set the enablement state of the filter called filterName to enabled.
	 *
	 * @param filterName
	 * @param enabled
	 * @param filters
	 */
	private void setEnablement(String filterName, boolean enabled, MarkerFilter[] filters) {
		for (MarkerFilter element : filters) {
			if (element.getName().equals(filterName)) {
				element.setEnabled(enabled);
				return;
			}
		}

	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerView#getMarkerName()
	 */
	@Override
	protected String getMarkerName() {
		return MarkerMessages.problem_title;
	}
}