/*******************************************************************************

 * Copyright (c) 2007, 2008 Wind River and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Wind River - Initial API and implementation

 *     Ericsson   - Low-level breakpoints integration

 *     Nokia - refactored to work for both GDB and EDC.  Nov. 2009.

 *******************************************************************************/

package org.eclipse.cdt.dsf.debug.service;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Hashtable;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.RejectedExecutionException;

import org.eclipse.cdt.dsf.concurrent.CountingRequestMonitor;

import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;

import org.eclipse.cdt.dsf.concurrent.DsfRunnable;

import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants;

import org.eclipse.cdt.dsf.concurrent.RequestMonitor;

import org.eclipse.cdt.dsf.concurrent.ThreadSafe;

import org.eclipse.cdt.dsf.datamodel.IDMContext;

import org.eclipse.cdt.dsf.debug.service.IBreakpoints.IBreakpointDMContext;

import org.eclipse.cdt.dsf.debug.service.IBreakpoints.IBreakpointsTargetDMContext;

import org.eclipse.cdt.dsf.internal.DsfPlugin;

import org.eclipse.cdt.dsf.service.AbstractDsfService;

import org.eclipse.cdt.dsf.service.DsfSession;

import org.eclipse.core.resources.IMarkerDelta;

import org.eclipse.core.runtime.CoreException;

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.debug.core.DebugPlugin;

import org.eclipse.debug.core.IBreakpointManager;

import org.eclipse.debug.core.IBreakpointManagerListener;

import org.eclipse.debug.core.IBreakpointsListener;

import org.eclipse.debug.core.model.IBreakpoint;

import org.osgi.framework.BundleContext;

/**

 * see these bugs for design of this service.<br>

 * - https://bugs.eclipse.org/bugs/show_bug.cgi?id=218557

 * - https://bugs.eclipse.org/bugs/show_bug.cgi?id=292468

 */

public class BreakpointsMediator extends AbstractDsfService implements IBreakpointManagerListener, IBreakpointsListener

{

	public enum BreakpointEventType {ADDED, REMOVED, MODIFIED}; 	

    /**

     * The attribute translator that this service will use to map the platform

     * breakpoint attributes to the corresponding target attributes, and vice

     * versa.

     */

    private IBreakpointAttributeTranslator fAttributeTranslator;

    /**

     * If the attribute translator implements the {@link IBreakpointAttributeTranslatorExtension},

     * this field will be valid, otherwise it is null.

     */

    private IBreakpointAttributeTranslatorExtension fAttributeTranslator2;

    /**

     * DSF Debug service for creating breakpoints.

     */

    IBreakpoints fBreakpointsService;

    /**

     * Platform breakpoint manager

     */

    IBreakpointManager fBreakpointManager;

    /**

     * Object describing the information about a single target breakpoint  

     * corresponding to specific platform breakpoint and breakpoint target 

     * context.

     * 

     * @since 2.1

     */

    public interface ITargetBreakpointInfo {

    	/**

    	 * Returns the breakpoint attributes as returned by the attribute translator.

    	 */

    	public Map<String, Object> getAttributes();

    	/**

    	 * Returns the target breakpoint context.  May be <code>null</code> if the 

    	 * breakpoint failed to install on target. 

    	 */

    	public IBreakpointDMContext getTargetBreakpoint();

    	/**

    	 * Returns the status result of the last breakpoint operation (install/remove). 

    	 */

    	public IStatus getStatus();

    }

    private static class TargetBP implements ITargetBreakpointInfo {

    	private Map<String, Object> fAttributes;

    	private IBreakpointDMContext fTargetBPContext;

    	private IStatus fStatus;

    	public TargetBP(Map<String, Object> attrs) {

    		fAttributes = attrs;

    	}

    	public Map<String, Object> getAttributes() {

			return fAttributes;

		}

    	public IBreakpointDMContext getTargetBreakpoint() {

			return fTargetBPContext;

		}

    	public IStatus getStatus() {

			return fStatus;

		}

		public void setTargetBreakpoint(IBreakpointDMContext fTargetBPContext) {

			this.fTargetBPContext = fTargetBPContext;

		}

		public void setStatus(IStatus status) {

			this.fStatus = status;

		}

    }

	private class PlatformBreakpointInfo {

		IBreakpoint 		breakpoint;

		boolean 			enabled;

		// All attributes available from UI, including standard and extended ones.

		Map<String, Object>	attributes;

		public PlatformBreakpointInfo(IBreakpoint bp, boolean enabled, Map<String, Object> attributes) {

			super();

			breakpoint = bp;

			this.enabled = enabled;

			this.attributes = attributes;

		}

	}

	///////////////////////////////////////////////////////////////////////////

    // Breakpoints tracking

    ///////////////////////////////////////////////////////////////////////////

    /**

     * Holds the set of platform breakpoints with their breakpoint information 

     * structures, per context (i.e. each platform breakpoint is

     * replicated for each execution context).

     * - Context entry added/removed on start/stopTrackingBreakpoints()

     * - Augmented on breakpointAdded()

     * - Modified on breakpointChanged()

     * - Diminished on breakpointRemoved()

     */

	private Map<IBreakpointsTargetDMContext, Map<IBreakpoint, List<TargetBP>>> fPlatformBPs = 

		new HashMap<IBreakpointsTargetDMContext, Map<IBreakpoint, List<TargetBP>>>();

	/**

	 * Holds platform breakpoints with all their attributes (standard ones and

	 * extended ones) from UI. This will be used to check what attributes have

	 * changed for a breakpoint when the breakpoint is changed. The map is <br>

	 * 1. augmented in doBreakpointsAdded(); <br>

	 * 2. updated in breakpointsChanged(); <br>

	 * 3. diminished in breakpointsRemoved();

	 */

	private Map<IBreakpoint, Map<String, Object>> fBreakpointAttributes = 

		new HashMap<IBreakpoint, Map<String, Object>>();

	private static class PendingEventInfo {

		PendingEventInfo(BreakpointEventType eventType, PlatformBreakpointInfo bpInfo,

				Collection<IBreakpointsTargetDMContext> bpsTargetDmc, RequestMonitor rm) {

			fEventType = eventType;

			fBPInfo = bpInfo;

			fBPTargetContexts = bpsTargetDmc;

			fRequestMonitor = rm;

			fAttributeDelta = null;

		}

		public PendingEventInfo(BreakpointEventType eventType, Collection<IBreakpointsTargetDMContext> updateContexts,

				Map<String, Object> attrDelta) {

			fEventType = eventType;

			fBPTargetContexts = updateContexts;

			fAttributeDelta = attrDelta;

			fRequestMonitor = null;

			fBPInfo = null;

		}

		PlatformBreakpointInfo fBPInfo;

		RequestMonitor fRequestMonitor;

		BreakpointEventType fEventType;

		Collection<IBreakpointsTargetDMContext> fBPTargetContexts;

		Map<String, Object>	fAttributeDelta;	// for change event only

	}

    /**

     * Due to the very asynchronous nature of DSF, a new breakpoint request can

     * pop up at any time before an ongoing one is completed. The following set

     * is used to store requests until the ongoing operation completes.

     */

	private Set<IBreakpoint> fRunningEvents    = new HashSet<IBreakpoint>();

	private Map<IBreakpoint, LinkedList<PendingEventInfo>> fPendingEvents = 

			new HashMap<IBreakpoint, LinkedList<PendingEventInfo>>();

    ///////////////////////////////////////////////////////////////////////////

    // AbstractDsfService    

    ///////////////////////////////////////////////////////////////////////////

	/**

	 * The service constructor

	 * 

	 * @param session

	 * @param debugModelId

	 */

	public BreakpointsMediator(DsfSession session, IBreakpointAttributeTranslator attributeTranslator) {

        super(session);

        fAttributeTranslator = attributeTranslator;

        fAttributeTranslator2 = null;

        if (attributeTranslator instanceof IBreakpointAttributeTranslatorExtension)

        	fAttributeTranslator2 = (IBreakpointAttributeTranslatorExtension)attributeTranslator;

	}

    @Override

    public void initialize(final RequestMonitor rm) {

        // - Collect references for the services we interact with

        // - Register to interesting events

        // - Obtain the list of platform breakpoints   

        // - Register the service for interested parties

        super.initialize(

            new RequestMonitor(getExecutor(), rm) { 

                @Override

                protected void handleSuccess() {

                    doInitialize(rm);

                }});

    }

    /**

     * Asynchronous service initialization 

     * 

     * @param requestMonitor

     */

    private void doInitialize(RequestMonitor rm) {

    	// Get the services references

        fBreakpointsService  = getServicesTracker().getService(IBreakpoints.class);

        fBreakpointManager = DebugPlugin.getDefault().getBreakpointManager();

        fAttributeTranslator.initialize(this);

        // Register to the useful events

        fBreakpointManager.addBreakpointListener(this);

        fBreakpointManager.addBreakpointManagerListener( this );

        // Register this service

        register(new String[] { BreakpointsMediator.class.getName() },

				 new Hashtable<String, String>());

        rm.done();

    }

    @Override

    public void shutdown(final RequestMonitor rm) {

        // - Un-register the service

        // - Stop listening to events

        // - Remove the breakpoints installed by this service

        // 

        //  Since we are shutting down, there is no overwhelming need

        //  to keep the maps coherent...

        // Stop accepting requests and events

    	unregister();

        fBreakpointManager.removeBreakpointListener(this);

        fBreakpointManager.removeBreakpointManagerListener( this );

        fAttributeTranslator.dispose();

        // Cleanup the breakpoints that are still installed by the service.

        // Use a counting monitor which will call mom to complete the shutdown

        // after the breakpoints are un-installed (successfully or not).

        CountingRequestMonitor countingRm = new CountingRequestMonitor(getExecutor(), rm) {

            @Override

            protected void handleCompleted() {

                BreakpointsMediator.super.shutdown(rm);

            }

        };

        // We have to make a copy of the fPlatformBPs keys because uninstallBreakpoints()

        // modifies the map as it walks through it.

        List<IBreakpointsTargetDMContext> platformBPKeysCopy = new ArrayList<IBreakpointsTargetDMContext>(fPlatformBPs.size());

        platformBPKeysCopy.addAll(0, fPlatformBPs.keySet());

        for (IBreakpointsTargetDMContext dmc : platformBPKeysCopy) {

            stopTrackingBreakpoints(dmc, countingRm);

        }

        countingRm.setDoneCount(platformBPKeysCopy.size());

    }

	@Override

    protected BundleContext getBundleContext() {

        return DsfPlugin.getBundleContext();

    }

    ///////////////////////////////////////////////////////////////////////////

    // IBreakpointsManager

    ///////////////////////////////////////////////////////////////////////////

	/**

     * Install and begin tracking breakpoints for given context.  The service 

     * will keep installing new breakpoints that appear in the IDE for this 

     * context until {@link #uninstallBreakpoints(IDMContext)} is called for that

     * context.

     * @param dmc Context to start tracking breakpoints for.

     * @param rm Completion callback.

     */

    public void startTrackingBreakpoints(final IBreakpointsTargetDMContext dmc, final RequestMonitor rm) {

        // - Augment the maps with the new execution context

        // - Install the platform breakpoints on the selected target

        // Make sure a mapping for this execution context does not already exist

		Map<IBreakpoint, List<TargetBP>> platformBPs = fPlatformBPs.get(dmc);

		if (platformBPs != null) {

            rm.setStatus(new Status(IStatus.ERROR, DsfPlugin.PLUGIN_ID, INTERNAL_ERROR, "Context already initialized", null)); //$NON-NLS-1$

            rm.done();            

            return;

		}

        // Create entries in the breakpoint tables for the new context. These entries should only

        // be removed when this service stops tracking breakpoints for the given context.

        fPlatformBPs.put(dmc, new HashMap<IBreakpoint, List<TargetBP>>());

        // Install the platform breakpoints (stored in fPlatformBPs) on the target.

		// We need to use a background thread for this operation because we are 

		// accessing the resources system to retrieve the breakpoint attributes.

		// Accessing the resources system potentially requires using global locks.

		// Also we will be calling IBreakpointAttributeTranslator which is prohibited

		// from being called on the session executor thread.

		new Job("Install initial breakpoint list.") { //$NON-NLS-1$

            { setSystem(true); }

			// Get the stored breakpoints from the platform BreakpointManager

			// and install them on the target

        	@Override

            protected IStatus run(IProgressMonitor monitor) {

        		doBreakpointsAdded(DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(), dmc, rm);

                return Status.OK_STATUS;

            }

        }.schedule();    

    }

    public void stopTrackingBreakpoints(final IBreakpointsTargetDMContext dmc, final RequestMonitor rm) {

        // - Remove the target breakpoints for the given execution context

        // - Update the maps

    	// Remove the breakpoints for given DMC from the internal maps.

        Map<IBreakpoint, List<TargetBP>> platformBPs = fPlatformBPs.get(dmc);

        if (platformBPs == null || platformBPs.size() == 0) {

            rm.setStatus(new Status(IStatus.INFO /* NOT error */, DsfPlugin.PLUGIN_ID, INTERNAL_ERROR, "Breakpoints not installed for given context", null)); //$NON-NLS-1$

            rm.done();

            return;

        }

        // Just remove the IBreakpoints installed for the "dmc".

        final IBreakpoint[] bps = platformBPs.keySet().toArray(new IBreakpoint[platformBPs.size()]);

		new Job("Uninstall target breakpoints list.") { //$NON-NLS-1$

            { setSystem(true); }

			// Get the stored breakpoints from the platform BreakpointManager

			// and install them on the target

        	@Override

            protected IStatus run(IProgressMonitor monitor) {

        		doBreakpointsRemoved(bps, dmc, rm);

                return Status.OK_STATUS;

            }

        }.schedule();    

    }

    /**

     * Find target breakpoints installed in the given context that are resolved 

     * from the given platform breakpoint.

     *  

     * @param dmc - context

     * @param platformBp - platform breakpoint

     * @return array of target breakpoints. 

     */

    public ITargetBreakpointInfo[] getTargetBreakpoints(IBreakpointsTargetDMContext dmc, IBreakpoint platformBp) {

    	assert getExecutor().isInExecutorThread();

        Map<IBreakpoint, List<TargetBP>> platformBPs = fPlatformBPs.get(dmc);

        if (platformBPs != null)

        {

        	List<TargetBP> bpInfo = platformBPs.get(platformBp);

            if (bpInfo != null) {

            	return bpInfo.toArray(new ITargetBreakpointInfo[bpInfo.size()]);

            }

        }

        return null;

    }

    /**

     * Find the platform breakpoint that's mapped to the given target breakpoint.

     * 

     * @param dmc - context of the target breakpoint, can be null.

     * @param bp - target breakpoint

     * @return platform breakpoint. null if not found. 

     */

    public IBreakpoint getPlatformBreakpoint(IBreakpointsTargetDMContext dmc, IBreakpointDMContext bp) {

    	assert getExecutor().isInExecutorThread();

    	for (IBreakpointsTargetDMContext bpContext : fPlatformBPs.keySet()) {

    		if (dmc != null && !dmc.equals(bpContext))

    			continue;

	        Map<IBreakpoint, List<TargetBP>> platformBPs = fPlatformBPs.get(bpContext);

	        if (platformBPs != null && platformBPs.size() > 0)

	        {

	            for(Map.Entry<IBreakpoint, List<TargetBP>> e: platformBPs.entrySet())

	            {

	                // Stop at the first occurrence

	            	for (TargetBP tbp : e.getValue())

	            		if(tbp.getTargetBreakpoint().equals(bp))

	            			return e.getKey();

	            }    

	        }

    	}

    	return null;

    }

    ///////////////////////////////////////////////////////////////////////////

    // Back-end interface functions

    ///////////////////////////////////////////////////////////////////////////

	/**

	 * Install a new platform breakpoint on the back-end. A platform breakpoint

	 * can resolve into multiple back-end breakpoints, e.g. when threads are taken

	 * into account.

	 *  

	 * @param dmc

	 * @param breakpoint

	 * @param attrsList - list of attribute map, each mapping to a potential target BP.

	 * @param rm

	 */

	private void installBreakpoint(IBreakpointsTargetDMContext dmc, final IBreakpoint breakpoint,

			final List<Map<String, Object>> attrsList, final DataRequestMonitor<List<TargetBP>> rm)

	{

    	// Retrieve the set of breakpoints for this context

        final Map<IBreakpoint, List<TargetBP>> platformBPs = fPlatformBPs.get(dmc);

        assert platformBPs != null;

        // Ensure the breakpoint is not already installed

        assert !platformBPs.containsKey(breakpoint);

        final ArrayList<TargetBP> targetBPsAttempted = new ArrayList<TargetBP>(attrsList.size());

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

        	targetBPsAttempted.add(new TargetBP(attrsList.get(i)));

        }

        final ArrayList<TargetBP> targetBPsInstalled = new ArrayList<TargetBP>(attrsList.size());

        // Update the breakpoint status when all back-end breakpoints have been installed

    	final CountingRequestMonitor installRM = new CountingRequestMonitor(getExecutor(), rm) {

			@Override

			protected void handleCompleted() {

				// Store successful targetBPs with the platform breakpoint

				if (targetBPsInstalled.size() > 0)

					platformBPs.put(breakpoint, targetBPsInstalled);

				// Store all targetBPs, success or failure, in the rm.

				rm.setData(targetBPsAttempted);

		        rm.done();

			}

		};

        // A back-end breakpoint needs to be installed for each specified attributes map.

		installRM.setDoneCount(attrsList.size());

		// Install the back-end breakpoint(s)

		for (int _i = 0; _i < attrsList.size(); _i++) {

			final int i = _i;

            fBreakpointsService.insertBreakpoint(

                dmc, attrsList.get(i), 

				new DataRequestMonitor<IBreakpointDMContext>(getExecutor(), installRM) {

				@Override

                protected void handleCompleted() {

					TargetBP targetBP = targetBPsAttempted.get(i);

                    if (isSuccess()) {

						// Add the breakpoint back-end mapping

                    	targetBP.setTargetBreakpoint(getData());

                    	targetBPsInstalled.add(targetBP);