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

 * Copyright (c) 2007, 2008 Wind River Systems 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 Systems - initial API and implementation

 *     Ericsson AB - expanded from initial stub

 *     Ericsson AB - added support for event handling

 *     Ericsson AB - added memory cache

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

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

import java.util.HashMap;

import java.util.Hashtable;

import java.util.LinkedList;

import java.util.ListIterator;

import java.util.Map;

import org.eclipse.cdt.core.IAddress;

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

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

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

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

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

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

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

import org.eclipse.cdt.dsf.debug.service.ICachingService;

import org.eclipse.cdt.dsf.debug.service.IExpressions;

import org.eclipse.cdt.dsf.debug.service.IMemory;

import org.eclipse.cdt.dsf.debug.service.IExpressions.IExpressionDMAddress;

import org.eclipse.cdt.dsf.debug.service.IExpressions.IExpressionDMContext;

import org.eclipse.cdt.dsf.debug.service.IRunControl.IContainerResumedDMEvent;

import org.eclipse.cdt.dsf.debug.service.IRunControl.IContainerSuspendedDMEvent;

import org.eclipse.cdt.dsf.debug.service.IRunControl.IResumedDMEvent;

import org.eclipse.cdt.dsf.debug.service.IRunControl.ISuspendedDMEvent;

import org.eclipse.cdt.dsf.debug.service.IRunControl.StateChangeReason;

import org.eclipse.cdt.dsf.debug.service.command.CommandCache;

import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService;

import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;

import org.eclipse.cdt.dsf.mi.service.MIExpressions.ExpressionChangedEvent;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIDataReadMemory;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIDataWriteMemory;

import org.eclipse.cdt.dsf.mi.service.command.output.MIDataReadMemoryInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIDataWriteMemoryInfo;

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

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

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

import org.eclipse.cdt.utils.Addr64;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

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

import org.osgi.framework.BundleContext;

/**

 * Memory service implementation

 */

public class MIMemory extends AbstractDsfService implements IMemory, ICachingService {

    public class MemoryChangedEvent extends AbstractDMEvent<IMemoryDMContext> 

        implements IMemoryChangedEvent 

    {

        IAddress[] fAddresses;

        IDMContext fContext;

        public MemoryChangedEvent(IMemoryDMContext context, IAddress[] addresses) {

            super(context);

            fAddresses = addresses;

        }

        public IAddress[] getAddresses() {

            return fAddresses;

        }

    }

	// Back-end commands cache

	private CommandCache fCommandCache;

	// Map of memory caches

    private Map<IMemoryDMContext, MIMemoryCache> fMemoryCaches;

    private MIMemoryCache getMemoryCache(IMemoryDMContext memoryDMC) {

    	MIMemoryCache cache = fMemoryCaches.get(memoryDMC);

    	if (cache == null) {

    		cache = new MIMemoryCache();

    		fMemoryCaches.put(memoryDMC, cache);

    	}

    	return cache;

    }

	/**

	 *  Constructor 

	 */

	public MIMemory(DsfSession session) {

		super(session);

    }

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

    // AbstractDsfService overrides

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

	/* (non-Javadoc)

	 * @see org.eclipse.cdt.dsf.service.AbstractDsfService#initialize(org.eclipse.cdt.dsf.concurrent.RequestMonitor)

	 * 

	 * This function is called during the launch sequence (where the service is 

	 * instantiated). See LaunchSequence.java.

	 */

	@Override

    public void initialize(final RequestMonitor requestMonitor) {

        super.initialize(new RequestMonitor(getExecutor(), requestMonitor) {

            @Override

            protected void handleSuccess() {

                doInitialize(requestMonitor);

            }

        });

    }

    /*

     * Initialization function:

     * - Register the service

     * - Create the command cache

     * - Register self to service events

     * 

     * @param requestMonitor

     */

    private void doInitialize(final RequestMonitor requestMonitor) {

    	// Create the command cache

        ICommandControlService commandControl = getServicesTracker().getService(ICommandControlService.class);

    	fCommandCache = new CommandCache(getSession(), commandControl);

    	fCommandCache.setContextAvailable(commandControl.getContext(), true);

    	// Register this service

    	register(new String[] { MIMemory.class.getName(), IMemory.class.getName() }, new Hashtable<String, String>());

    	// Create the memory requests cache

    	fMemoryCaches = new HashMap<IMemoryDMContext, MIMemoryCache>();

		// Register as service event listener

    	getSession().addServiceEventListener(this, null);

    	// Done 

    	requestMonitor.done();

    }

    /* (non-Javadoc)

     * @see org.eclipse.cdt.dsf.service.AbstractDsfService#shutdown(org.eclipse.cdt.dsf.concurrent.RequestMonitor)

     */

    @Override

    public void shutdown(final RequestMonitor requestMonitor) {

    	// Unregister this service

        unregister();

		// Remove event listener

    	getSession().removeServiceEventListener(this);

    	// Complete the shutdown

        super.shutdown(requestMonitor);

    }

    /* (non-Javadoc)

     * @see org.eclipse.cdt.dsf.service.AbstractDsfService#getBundleContext()

     */

    @Override

    protected BundleContext getBundleContext() {

        return GdbPlugin.getBundleContext();

    }

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

    // IMemory

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

    /* (non-Javadoc)

     * @see org.eclipse.cdt.dsf.debug.service.IMemory#getMemory(org.eclipse.cdt.dsf.datamodel.IDMContext, org.eclipse.cdt.core.IAddress, long, int, org.eclipse.cdt.dsf.concurrent.DataRequestMonitor)

     */

    public void getMemory(IMemoryDMContext memoryDMC, IAddress address, long offset,

    		int word_size, int count, DataRequestMonitor<MemoryByte[]> drm)

	{

        // Validate the context

        if (memoryDMC == null) {

            drm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Unknown context type", null)); //$NON-NLS-1$);

            drm.done();            

            return;

        }

        // Validate the word size

    	// NOTE: We only accept 1 byte words for this implementation

    	if (word_size != 1) {

    		drm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, NOT_SUPPORTED, "Word size not supported (!= 1)", null)); //$NON-NLS-1$

    		drm.done();

    		return;

    	}

    	// Validate the byte count

    	if (count < 0) {

    		drm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, IDsfStatusConstants.INTERNAL_ERROR, "Invalid word count (< 0)", null)); //$NON-NLS-1$

    		drm.done();

    		return;

    	}

    	// All is clear: go for it

    	getMemoryCache(memoryDMC).getMemory(memoryDMC, address.add(offset), word_size, count, drm);

	}

    /* (non-Javadoc)

     * @see org.eclipse.cdt.dsf.debug.service.IMemory#setMemory(org.eclipse.cdt.dsf.datamodel.IDMContext, org.eclipse.cdt.core.IAddress, long, int, byte[], org.eclipse.cdt.dsf.concurrent.RequestMonitor)

     */

    public void setMemory(IMemoryDMContext memoryDMC, IAddress address, long offset,

    		int word_size, int count, byte[] buffer, RequestMonitor rm)

    {

        // Validate the context

        if (memoryDMC == null) {

            rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Unknown context type", null)); //$NON-NLS-1$);

            rm.done();            

            return;

        }

    	// Validate the word size

    	// NOTE: We only accept 1 byte words for this implementation

    	if (word_size != 1) {

    		rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, NOT_SUPPORTED, "Word size not supported (!= 1)", null)); //$NON-NLS-1$

    		rm.done();

    		return;

    	}

    	// Validate the byte count

    	if (count < 0) {

    		rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, IDsfStatusConstants.INTERNAL_ERROR, "Invalid word count (< 0)", null)); //$NON-NLS-1$

    		rm.done();

    		return;

    	}

    	// Validate the buffer size

    	if (buffer.length < count) {

    		rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, IDsfStatusConstants.INTERNAL_ERROR, "Buffer too short", null)); //$NON-NLS-1$

    		rm.done();

    		return;

    	}

    	// All is clear: go for it

    	getMemoryCache(memoryDMC).setMemory(memoryDMC, address, offset, word_size, count, buffer, rm);

    }

    /* (non-Javadoc)

     * @see org.eclipse.cdt.dsf.debug.service.IMemory#fillMemory(org.eclipse.cdt.dsf.datamodel.IDMContext, org.eclipse.cdt.core.IAddress, long, int, byte[], org.eclipse.cdt.dsf.concurrent.RequestMonitor)

     */

    public void fillMemory(IMemoryDMContext memoryDMC, IAddress address, long offset,

    		int word_size, int count, byte[] pattern, RequestMonitor rm)

    {

        // Validate the context

        if (memoryDMC == null) {

            rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Unknown context type", null)); //$NON-NLS-1$);

            rm.done();            

            return;

        }

    	// Validate the word size

    	// NOTE: We only accept 1 byte words for this implementation

    	if (word_size != 1) {

    		rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, NOT_SUPPORTED, "Word size not supported (!= 1)", null)); //$NON-NLS-1$

    		rm.done();

    		return;

    	}

    	// Validate the repeat count

    	if (count < 0) {

    		rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, IDsfStatusConstants.INTERNAL_ERROR, "Invalid repeat count (< 0)", null)); //$NON-NLS-1$

    		rm.done();

    		return;

    	}

    	// Validate the pattern

    	if (pattern.length < 1) {

    		rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, IDsfStatusConstants.INTERNAL_ERROR, "Empty pattern", null)); //$NON-NLS-1$

    		rm.done();

    		return;

    	}

    	// Create an aggregate buffer so we can write in 1 shot

    	int length = pattern.length;

    	byte[] buffer = new byte[count * length];

    	for (int i = 0; i < count; i++) {

    		System.arraycopy(pattern, 0, buffer, i * length, length);

    	}

    	// All is clear: go for it

    	getMemoryCache(memoryDMC).setMemory(memoryDMC, address, offset, word_size, count * length, buffer, rm);

    }

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

    // Back-end functions 

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

    /**

     * @param memoryDMC

     * @param address

     * @param offset

     * @param word_size

     * @param count

     * @param drm

     * 

     * @since 1.1

     */

    protected void readMemoryBlock(IDMContext dmc, IAddress address, final long offset,

    		final int word_size, final int count, final DataRequestMonitor<MemoryByte[]> drm)

    {

    	/* To simplify the parsing of the MI result, we request the output to

    	 * be on 1 row of [count] columns, no char interpretation.

    	 */

    	int mode = MIFormat.HEXADECIMAL;

    	int nb_rows = 1;

    	int nb_cols = count;

    	Character asChar = null;

    	fCommandCache.execute(

    			new MIDataReadMemory(dmc, offset, address.toString(), mode, word_size, nb_rows, nb_cols, asChar),

    			new DataRequestMonitor<MIDataReadMemoryInfo>(getExecutor(), drm) {

    				@Override

    				protected void handleSuccess() {

    					// Retrieve the memory block

    					drm.setData(getData().getMIMemoryBlock());

    					drm.done();

    				}

    				@Override

    				protected void handleFailure() {

    					// Bug234289: If memory read fails, return a block marked as invalid

    					MemoryByte[] block = new MemoryByte[word_size * count];

    					for (int i = 0; i < block.length; i++)

    						block[i] = new MemoryByte((byte) 0, (byte) 0);

    					drm.setData(block);

    					drm.done();

    				}

    			}

    	);

    }

    /**

     * @param memoryDMC

     * @param address

     * @param offset

     * @param word_size

     * @param count

     * @param buffer

     * @param rm

     * 

     * @since 1.1

     */

    protected void writeMemoryBlock(final IDMContext dmc, final IAddress address, final long offset,

    		final int word_size, final int count, final byte[] buffer, final RequestMonitor rm)

    {

    	// Each byte is written individually (GDB power...)

    	// so we need to keep track of the count

    	final CountingRequestMonitor countingRM = new CountingRequestMonitor(getExecutor(), rm);

    	countingRM.setDoneCount(count);

    	// We will format the individual bytes in decimal

    	int format = MIFormat.DECIMAL;

    	String baseAddress = address.toString();

    	// Issue an MI request for each byte to write

    	for (int i = 0; i < count; i++) {

    		String value = new Byte(buffer[i]).toString();

    		fCommandCache.execute(

    				new MIDataWriteMemory(dmc, offset + i, baseAddress, format, word_size, value),

    				new DataRequestMonitor<MIDataWriteMemoryInfo>(getExecutor(), countingRM)

    		);

    	}

    }

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

    // Event handlers

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

    /**

     * @nooverride This method is not intended to be re-implemented or extended by clients.

     * @noreference This method is not intended to be referenced by clients.

     */

    @DsfServiceEventHandler

	public void eventDispatched(IResumedDMEvent e) {

    	if (e instanceof IContainerResumedDMEvent) {

    		fCommandCache.setContextAvailable(e.getDMContext(), false);

    	}

   		if (e.getReason() != StateChangeReason.STEP) {

	    	fCommandCache.reset(e.getDMContext());

	    	IMemoryDMContext memoryDMC = DMContexts.getAncestorOfType(e.getDMContext(), IMemoryDMContext.class);

	    	if (fMemoryCaches.containsKey(memoryDMC)) {

	    		// We do not want to use the call to getMemoryCache() here.

	    		// This is because:

	    		// 1- if there is not an entry already , we do not want to automatically 

	    		//    create one, just to call reset() on it.

	    		// 2- if memoryDMC == null, we do not want to create a cache

	    		//    entry for which the key is 'null'

	    		fMemoryCaches.get(memoryDMC).reset();

	    	}

   		}

	}

    /**

     * @nooverride This method is not intended to be re-implemented or extended by clients.

     * @noreference This method is not intended to be referenced by clients.

     */

    @DsfServiceEventHandler

	public void eventDispatched(ISuspendedDMEvent e) {

    	if (e instanceof IContainerSuspendedDMEvent) {

    		fCommandCache.setContextAvailable(e.getDMContext(), true);

    	}

    	fCommandCache.reset(e.getDMContext());

    	IMemoryDMContext memoryDMC = DMContexts.getAncestorOfType(e.getDMContext(), IMemoryDMContext.class);

    	if (fMemoryCaches.containsKey(memoryDMC)) {

    		// We do not want to use the call to getMemoryCache() here.

    		// This is because:

    		// 1- if there is not an entry already , we do not want to automatically 

    		//    create one, just to call reset() on it.

    		// 2- if memoryDMC == null, we do not want to create a cache

    		//    entry for which the key is 'null'

    		fMemoryCaches.get(memoryDMC).reset();

    	}

	}

    /**

     * @nooverride This method is not intended to be re-implemented or extended by clients.

     * @noreference This method is not intended to be referenced by clients.

     */

   	@DsfServiceEventHandler

	public void eventDispatched(ExpressionChangedEvent e) {

   		// Get the context and expression service handle

   		final IExpressionDMContext context = e.getDMContext();

		IExpressions expressionService = getServicesTracker().getService(IExpressions.class);

		// Get the variable information and update the corresponding memory locations

		if (expressionService != null) {

			expressionService.getExpressionAddressData(context,

				new DataRequestMonitor<IExpressionDMAddress>(getExecutor(), null) {

					@Override

					protected void handleSuccess() {

						// Figure out which memory area was modified

						IExpressionDMAddress expression = getData();

						final int count = expression.getSize();

						final Addr64 address;

						if (expAddress instanceof Addr64)

							address = (Addr64) expAddress;

						else

						final IMemoryDMContext memoryDMC = DMContexts.getAncestorOfType(context, IMemoryDMContext.class);

						getMemoryCache(memoryDMC).refreshMemory(memoryDMC, address, 0, 1, count,

								new RequestMonitor(getExecutor(), null));

						}

			});

		}

	}

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

	// SortedLinkedlist

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

	// This class is really the equivalent of a C struct (old habits die hard...)

   	// For simplicity, everything is public.

   	private class MemoryBlock {

		public IAddress fAddress;

		public long fLength;

		public MemoryByte[] fBlock;

		public MemoryBlock(IAddress address, long length, MemoryByte[] block) {

			fAddress = address;

			fLength = length;

			fBlock = block;

		}

	}

   	// Address-ordered data structure to cache the memory blocks.

   	// Contiguous blocks are merged if possible.

	@SuppressWarnings("serial")

	private class SortedMemoryBlockList extends LinkedList<MemoryBlock> {

		public SortedMemoryBlockList() {

			super();

		}

		// Insert the block in the sorted linked list and merge contiguous

		// blocks if necessary

		@Override

		public boolean add(MemoryBlock block) {

			// If the list is empty, just store the block

			if (isEmpty()) {

				addFirst(block);

				return true;

			}

			// Insert the block at the correct location and then

			// merge the blocks if possible

			ListIterator<MemoryBlock> it = listIterator();

			while (it.hasNext()) {

				int index = it.nextIndex();

				MemoryBlock item = it.next();

				if (block.fAddress.compareTo(item.fAddress) < 0) {

					add(index, block);

					compact(index);

					return true;

				}

			}

			// Put at the end of the list and merge if necessary 

			addLast(block);

			compact(size() - 1);

			return true;

		}

		// Merge this block with its contiguous neighbors (if any)

		// Note: Merge is not performed if resulting block size would exceed MAXINT

		private void compact(int index) {

			MemoryBlock newBlock = get(index); 

			// Case where the block is to be merged with the previous block

			if (index > 0) {

				MemoryBlock prevBlock = get(index - 1);

				IAddress endOfPreviousBlock = prevBlock.fAddress.add(prevBlock.fLength);

				if (endOfPreviousBlock.distanceTo(newBlock.fAddress).longValue() == 0) {

					long newLength = prevBlock.fLength + newBlock.fLength;

					if (newLength <= Integer.MAX_VALUE) {