/*******************************************************************************
 * Copyright (c) 2009, 2018 R.Dvorak 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
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *     Radek Dvorak - initial API and implementation
 *******************************************************************************/
package org.eclipse.m2m.qvt.oml.debug.core;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IMarkerDelta;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IBreakpointManager;
import org.eclipse.debug.core.IBreakpointManagerListener;
import org.eclipse.debug.core.IDebugEventSetListener;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.IStatusHandler;
import org.eclipse.debug.core.model.IBreakpoint;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IMemoryBlock;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.core.model.IThread;
import org.eclipse.debug.core.model.IValue;
import org.eclipse.emf.common.util.URI;
import org.eclipse.m2m.internal.qvt.oml.ast.env.QvtOperationalEvaluationEnv;
import org.eclipse.m2m.qvt.oml.debug.core.vm.IQVTOVirtualMachineShell;
import org.eclipse.m2m.qvt.oml.debug.core.vm.QVTOVirtualMachine;
import org.eclipse.m2m.qvt.oml.debug.core.vm.VMEventListener;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.NewBreakpointData;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMBreakpointRequest;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMBreakpointResponse;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMDisconnectEvent;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMEvent;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMRequest;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMResponse;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMResumeEvent;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMResumeRequest;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMStartEvent;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMStartRequest;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMSuspendEvent;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMSuspendRequest;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMTerminateEvent;
import org.eclipse.m2m.qvt.oml.debug.core.vm.protocol.VMTerminateRequest;

public class QVTODebugTarget extends QVTODebugElement implements IQVTODebugTarget, IDebugEventSetListener, IBreakpointManagerListener {

	private final Map<Long, QVTOBreakpoint> fID2Breakpoint = new HashMap<Long, QVTOBreakpoint>();

	private final ILaunch fLaunch;

	private final IProcess fProcess;

	private QVTOThread fMainThread;
	
	private String fMainModuleName;

	private boolean fIsStarting;
	private boolean fIsSuspended = false;

	private final IQVTOVirtualMachineShell fVM;
	private final List<VMEventListener> fEventListener = new LinkedList<VMEventListener>();

	private final Object fVMStartMonitor = new Object();

	public QVTODebugTarget(IProcess process, IQVTOVirtualMachineShell vm) {
		super(null);

		fLaunch = process.getLaunch();
		fProcess = process;
		fVM = vm;
		fIsStarting = true;
		fEventListener.add(createVMEventListener());

		EventDispatchJob dispatcher = new EventDispatchJob();
		Thread eventDispatherThread = new Thread(dispatcher, "QVTO VM Event Dispatch"); //$NON-NLS-1$			
		eventDispatherThread.setDaemon(true);
		eventDispatherThread.start();

		try {
			// start transformation execution				
			sendRequest(new VMStartRequest());
		} catch (DebugException e) {
			QVTODebugCore.log(e.getStatus());
			// FIXME - consult status handler to give UI feedback
			return;
		}
		
		joinStartOrTerminate();
		// Note: VM is still suspended and waiting for resume
		// => do whatever initialization we need now
		// install VM breakpoints
		installVMBreakpoints();
		
		DebugEvent createEvent = new DebugEvent(this, DebugEvent.CREATE);
		createEvent.setData(new HashMap<Long, QVTOBreakpoint>(fID2Breakpoint));

		fMainThread = new QVTOThread(this);
		fLaunch.addDebugTarget(this);
		System.setProperty(QVTODebugCore.DEBUGGER_ACTIVE_PROPERTY, Boolean.TRUE.toString());		

		try {
			// wake up so far suspended VM
			fVM.sendRequest(new VMResumeRequest(0));
		} catch (IOException e) {
			QVTODebugCore.log(e);
		}
		
		IBreakpointManager breakpointManager = DebugPlugin.getDefault().getBreakpointManager();
		breakpointManager.addBreakpointManagerListener(this);
		breakpointManager.addBreakpointListener(this);
		DebugPlugin.getDefault().addDebugEventListener(this);

		fireEvent(createEvent);
	}

	protected URI computeBreakpointURI(URI sourceURI) {
		return sourceURI;
	}
	
	private void installVMBreakpoints() {
		HashMap<Long, QVTOBreakpoint> installedBreakpoints = new HashMap<Long, QVTOBreakpoint>();
		List<NewBreakpointData> allBpData = new ArrayList<NewBreakpointData>();
		
		for (QVTOBreakpoint qvtBp : QVTODebugCore.getQVTOBreakpoints(QVTOBreakpoint.class)) {
			boolean enabled = false;
			try {
				enabled = qvtBp.isEnabled();
			} catch (CoreException e) {
				QVTODebugCore.log(e.getStatus());
			}

			if (enabled) {
				installedBreakpoints.put(new Long(((QVTOBreakpoint) qvtBp).getID()), qvtBp);
				try {
					NewBreakpointData data = qvtBp.createNewBreakpointData();
					data.targetURI = computeBreakpointURI(URI.createURI(data.targetURI, true)).toString();
					
					allBpData.add(data);
				} catch (CoreException e) {
					QVTODebugCore.log(e.getStatus());
				} catch (Exception e) {
					QVTODebugCore.log(QVTODebugUtil.createDebugError("Failed to install breakpoint", e));
				}
			}
		}

		if (!allBpData.isEmpty()) {
			VMBreakpointRequest breakpointRequest = VMBreakpointRequest
					.createAdd(allBpData
							.toArray(new NewBreakpointData[allBpData.size()]));
			try {
				VMResponse response = fVM.sendRequest(breakpointRequest);
				// 
				fID2Breakpoint.clear();
				if(response instanceof VMBreakpointResponse) {
					VMBreakpointResponse bpResponse = (VMBreakpointResponse) response;
					
					for(long addedID : bpResponse.getAddedBreakpointsIDs()) {
						Long key = new Long(addedID);
						QVTOBreakpoint bp = installedBreakpoints.get(key);
						if(bp != null) {
							fID2Breakpoint.put(key, bp);
						}
					}
				}
			} catch (IOException e) {
				QVTODebugCore.log(e);
			}
		}
	}
	
	public Collection<? extends IBreakpoint> getInstalledBreakpoints() {
		return Collections.unmodifiableCollection(fID2Breakpoint.values());
	}

	public VMResponse sendRequest(VMRequest request) throws DebugException {
		try {
			return fVM.sendRequest(request);
		} catch (IOException e) {
			throw new DebugException(QVTODebugUtil.createDebugError(
					"Send debug request failed", e));
		}
	}

	public synchronized boolean isSuspended() {
		return !isTerminated() && fIsSuspended;
	}

	@Override
	public IDebugTarget getDebugTarget() {
		return this;
	}

	@Override
	public ILaunch getLaunch() {
		return fLaunch;
	}

	public IQVTOVirtualMachineShell getVM() {
		return fVM;
	}

	public IProcess getProcess() {
		IProcess[] processes = getLaunch().getProcesses();
		if (processes != null && processes.length > 0) {
			return processes[0];
		}

		return null;
	}

	public boolean hasThreads() throws DebugException {
		return !isTerminated();
	}

	public IThread[] getThreads() throws DebugException {
		return (fMainThread != null) ? new IThread[] { fMainThread }
				: new IThread[0];
	}

	public String getName() throws DebugException {
		return "QVTO Debug target";
	}

	public boolean supportsBreakpoint(IBreakpoint breakpoint) {
		return breakpoint.getModelIdentifier().equals(getModelIdentifier());
	}

	public boolean canTerminate() {
		return !isTerminated();
	}

	public boolean isTerminated() {
		return fVM.isTerminated();
	}

	public void terminate() throws DebugException {
		sendRequest(new VMTerminateRequest());
	}

	protected void started(String mainModuleName) {
		setMainModuleName(mainModuleName);
		setStarting(false);		
	}
		
	synchronized protected void setMainModuleName(String mainModuleName) {
		fMainModuleName = mainModuleName;
	}
	
	synchronized public String getMainModuleName() {
		return fMainModuleName;
	}
		
	protected void terminated() {
		QVTODebugCore.TRACE.trace(DebugOptions.TARGET, "Debug target terminated"); //$NON-NLS-1$
		System.setProperty(QVTODebugCore.DEBUGGER_ACTIVE_PROPERTY, Boolean.FALSE.toString());		

		setStarting(false);
		
		fMainThread = null;

		DebugPlugin debugPlugin = DebugPlugin.getDefault();
		if (debugPlugin != null) {
			IBreakpointManager breakpointManager = debugPlugin
					.getBreakpointManager();
			breakpointManager.removeBreakpointListener(this);
			breakpointManager.removeBreakpointManagerListener(this);

			debugPlugin.removeDebugEventListener(this);
		}

		fID2Breakpoint.clear();
		
		fireTerminateEvent();
		if(fProcess instanceof QVTOVirtualProcess) {
			QVTOVirtualProcess vp = (QVTOVirtualProcess) fProcess;
			vp.terminated();
		}
	}

	public boolean canResume() {
		return !isTerminated() && isSuspended();
	}

	public boolean canSuspend() {
		return !isTerminated() && !isSuspended();
	}

	public void resume() throws DebugException {
		sendRequest(new VMResumeRequest(DebugEvent.UNSPECIFIED));
	}

	public void suspend() throws DebugException {
		sendRequest(new VMSuspendRequest(DebugEvent.UNSPECIFIED));
	}

	public void breakpointAdded(IBreakpoint breakpoint) {
		if (breakpoint instanceof QVTOBreakpoint == false
				|| !DebugPlugin.getDefault().getBreakpointManager().isEnabled()) {
			return;
		}

		QVTOBreakpoint qvtBreakpoint = (QVTOBreakpoint) breakpoint;
		try {
			NewBreakpointData bpData = qvtBreakpoint.createNewBreakpointData();
			VMBreakpointRequest addBreakpointRequest = VMBreakpointRequest
					.createAdd(bpData);

			VMResponse response = sendRequest(addBreakpointRequest);
			if(response instanceof VMBreakpointResponse) {
				VMBreakpointResponse bpResponse = (VMBreakpointResponse) response;
				long[] addedIDs = bpResponse.getAddedBreakpointsIDs();
				if(addedIDs.length > 0) {
					fID2Breakpoint.put(new Long(addedIDs[0]), qvtBreakpoint);
				}
			}
		} catch (CoreException e) {
			QVTODebugCore.log(e.getStatus());
		}
	}

	public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
		if (breakpoint instanceof QVTOBreakpoint == false
				|| !DebugPlugin.getDefault().getBreakpointManager().isEnabled()) {
			return;
		}

		boolean nowEnabled = false;
		try {
			nowEnabled = breakpoint.isEnabled();
		} catch (CoreException e1) {
			// do nothing
		}
		boolean beforeEnabled = delta.getAttribute(IBreakpoint.ENABLED, false);

		VMBreakpointRequest changeRequest = null;
		try {
			QVTOBreakpoint qvtBreakpoint = (QVTOBreakpoint) breakpoint;
			if (nowEnabled && !beforeEnabled) {
				// just to be added to VM
				changeRequest = VMBreakpointRequest
						.createAdd(new NewBreakpointData[] { qvtBreakpoint
								.createNewBreakpointData() });
			} else if (!nowEnabled && beforeEnabled) {
				// just to be removed from VM
				changeRequest = VMBreakpointRequest.createRemove(qvtBreakpoint
						.getID());
			} else {
				// modify existing data
				changeRequest = VMBreakpointRequest.createChange(qvtBreakpoint
						.getID(), qvtBreakpoint.createBreakpointData());
			}

		} catch (CoreException e) {
			QVTODebugCore.log(e);
		}

		if (changeRequest != null) {
			try {
				fVM.sendRequest(changeRequest);
			} catch (IOException e) {
				QVTODebugCore.log(e);
			}
		}
	}

	public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
		if (breakpoint instanceof QVTOBreakpoint) {
			if (delta == null) {
				IMarker marker = breakpoint.getMarker();
				if (marker.exists()) {
					try {
						marker.delete();
					} catch (CoreException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
			QVTOBreakpoint qvtBreakpoint = (QVTOBreakpoint) breakpoint;
			fID2Breakpoint.remove(new Long(((QVTOBreakpoint) breakpoint)
					.getID()));

			VMBreakpointRequest removeRequest = VMBreakpointRequest
					.createRemove(qvtBreakpoint.getID());
			try {
				fVM.sendRequest(removeRequest);
			} catch (IOException e) {
				QVTODebugCore.log(e);
			}
		}
	}

	public boolean canDisconnect() {
		return false;
	}

	public void disconnect() throws DebugException {
	}

	public boolean isDisconnected() {
		return false;
	}

	public boolean supportsStorageRetrieval() {
		return false;
	}

	public IMemoryBlock getMemoryBlock(long startAddress, long length) throws DebugException {
		return null;
	}

	public void handleDebugEvents(DebugEvent[] events) {
		for (int i = 0; i < events.length; i++) {
			DebugEvent event = events[i];

			if (event.getKind() == DebugEvent.TERMINATE) {
				// respond
				if ((fMainThread != null && event.getSource() == fMainThread)
						|| (event.getSource() == fProcess)) {
					if(!isTerminated()) {
						terminated();
					}
				}
			}
		}
	}

	public void breakpointManagerEnablementChanged(boolean enabled) {
		for (IBreakpoint breakpoint : QVTODebugCore
				.getQVTOBreakpoints(IBreakpoint.class)) {
			if (enabled) {
				breakpointAdded(breakpoint);
			} else {
				breakpointRemoved(breakpoint, null);
			}
		}
	}
	
	private void joinStartOrTerminate() {
		synchronized (fVMStartMonitor) {
			while(fIsStarting) {
				try {
					// wait until we receive VM startup event
					fVMStartMonitor.wait();
				} catch (InterruptedException e) {
					Thread.interrupted();
				}
			}
		}
	}
	
		
	private void setStarting(boolean isStarting) {
		synchronized (fVMStartMonitor) {
			fIsStarting = isStarting;
			fVMStartMonitor.notify();
		}
	}
	
	private void handleBreakpointConditionError(VMSuspendEvent suspend) {
		IStatus breakpointStatus = new BreakpointError(suspend
				.getBreakpointID(), suspend.getReason(),
				suspend.getReasonDetail());
		
		IStatusHandler handler = DebugPlugin.getDefault().getStatusHandler(breakpointStatus);
		if(handler != null) {
			try {
				handler.handleStatus(breakpointStatus, QVTODebugTarget.this);									
			} catch (CoreException e) {
				QVTODebugCore.log(e.getStatus());
			}
		} else {
			// no custom handler found, at least log the status
			QVTODebugCore.log(breakpointStatus);
		}
	}	
	
	private VMEventListener createVMEventListener() {
		return new VMEventListener() {
			
			public void handleEvent(VMEvent event) { 
				if (event instanceof VMResumeEvent) {
					fIsSuspended = false;
					fireResumeEvent(0);
				} else if (event instanceof VMSuspendEvent) {
					fIsSuspended = true;
					
					VMSuspendEvent suspend = (VMSuspendEvent) event;					
					fireSuspendEvent(suspend.detail);
					
					if (suspend.detail == VMSuspendEvent.BREAKPOINT_CONDITION_ERR) {
						handleBreakpointConditionError(suspend);
					}
					
				} else if (event instanceof VMTerminateEvent) {
					fIsSuspended = false;
					terminated();
				} else if (event instanceof VMDisconnectEvent) {
					fIsSuspended = false;
					terminated();
				} else if (event instanceof VMStartEvent) {					
					started(((VMStartEvent) event).mainModuleName);
				}
			}

		};
	}

	public void addVMEventListener(VMEventListener listener) {
		if (listener == null) {
			throw new IllegalArgumentException();
		}

		synchronized (fEventListener) {
			fEventListener.add(listener);
		}
	}

	public boolean removeVMEventListener(VMEventListener listener) {
		synchronized (fEventListener) {
			return fEventListener.remove(listener);
		}
	}

	void handleVMEvent(VMEvent event) {
		List<VMEventListener> listeners;
		synchronized (fEventListener) {
			listeners = new ArrayList<VMEventListener>(fEventListener);
		}

		for (VMEventListener vmEventListener : listeners) {
			try {
				vmEventListener.handleEvent(event);
			} catch (Exception e) {
				QVTODebugCore.log(e);
			}
		}
	}
	
	public IValue evaluate(String expressionText, long frameID) throws CoreException {
		if (getVM() instanceof QVTOVirtualMachine) {
			return ((QVTOVirtualMachine) getVM()).evaluate(expressionText, this, frameID);
		}
		return null;
	}
	
	@Override
	public Object getAdapter(Class adapter) {
		if (QvtOperationalEvaluationEnv.class == adapter) {
			if (getVM() instanceof QVTOVirtualMachine) {
				return ((QVTOVirtualMachine) getVM()).getEvaluationEnv();
			}
		}
		return super.getAdapter(adapter);
	}
	
	private class EventDispatchJob implements Runnable {

		EventDispatchJob() {
			super();
		}

		public void run() {
			while (!isTerminated()) {
				VMEvent event;
				try {
					event = fVM.readVMEvent();
				} catch (IOException e) {
					break;
				}

				if (event != null) {
					handleVMEvent(event);
				}
			}

			QVTODebugCore.TRACE.trace(DebugOptions.TARGET,
					"Debug target VMEvent dispatcher shutdown"); //$NON-NLS-1$
		}
	}

}