package org.eclipse.cdt.debug.dap;

import static org.eclipse.cdt.debug.internal.ui.disassembly.dsf.DisassemblyUtils.DEBUG;

import java.math.BigInteger;
import java.text.MessageFormat;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import org.eclipse.cdt.debug.dap.CDTDebugProtocol.CDTDisassembleArguments;
import org.eclipse.cdt.debug.internal.ui.disassembly.dsf.AbstractDisassemblyBackend;
import org.eclipse.cdt.debug.internal.ui.disassembly.dsf.AddressRangePosition;
import org.eclipse.cdt.debug.internal.ui.disassembly.dsf.DisassemblyUtils;
import org.eclipse.cdt.debug.internal.ui.disassembly.dsf.ErrorPosition;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.model.ISourceLocator;
import org.eclipse.debug.core.model.IVariable;
import org.eclipse.debug.core.sourcelookup.ISourceLookupDirector;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Position;
import org.eclipse.lsp4e.debug.debugmodel.DSPDebugTarget;
import org.eclipse.lsp4e.debug.debugmodel.DSPStackFrame;
import org.eclipse.lsp4j.debug.DisassembleResponse;
import org.eclipse.lsp4j.debug.DisassembledInstruction;
import org.eclipse.lsp4j.debug.Source;

@SuppressWarnings("restriction")
public class DapDisassemblyBackend extends AbstractDisassemblyBackend {

	private DSPStackFrame dspStackFrame;

	@Override
	public boolean supportsDebugContext(IAdaptable context) {
		return context instanceof DSPStackFrame;
	}

	@Override
	public boolean hasDebugContext() {
		return dspStackFrame != null;
	}

	@Override
	public SetDebugContextResult setDebugContext(IAdaptable context) {
		assert context instanceof DSPStackFrame;
		SetDebugContextResult setDebugContextResult = new SetDebugContextResult();
		if (context instanceof DSPStackFrame) {

			DSPStackFrame newDspStackFrame = (DSPStackFrame) context;
			setDebugContextResult.contextChanged = !newDspStackFrame.equals(dspStackFrame);
			dspStackFrame = newDspStackFrame;
			// sessionId should have been boolean and been hasSessionId, only null/non-null is relevant
			setDebugContextResult.sessionId = ""; //$NON-NLS-1$
			if (!setDebugContextResult.contextChanged) {
				fCallback.gotoFrameIfActive(dspStackFrame.getDepth());
			}
		} else {
			setDebugContextResult.contextChanged = true;
			setDebugContextResult.sessionId = null;
		}

		return setDebugContextResult;
	}

	@Override
	public void clearDebugContext() {
		dspStackFrame = null;
	}

	@Override
	public void retrieveFrameAddress(int frame) {
		fCallback.setUpdatePending(false);
		fCallback.asyncExec(() -> {
			int addressBits = dspStackFrame.getFrameInstructionAddressBits();
			BigInteger address = dspStackFrame.getFrameInstructionAddress();
			if (addressBits != fCallback.getAddressSize()) {
				fCallback.addressSizeChanged(addressBits);
			}
			if (frame == 0) {
				fCallback.updatePC(address);
			} else {
				fCallback.gotoFrame(frame, address);
			}
		});
	}

	@Override
	public int getFrameLevel() {
		return dspStackFrame.getDepth();
	}

	@Override
	public boolean isSuspended() {
		return dspStackFrame.getDebugTarget().isSuspended();
	}

	@Override
	public boolean hasFrameContext() {

		return false;
	}

	@Override
	public String getFrameFile() {

		return null;
	}

	@Override
	public int getFrameLine() {

		return 0;
	}

	/**
	 * Retrieves disassembly based on either (a) start and end address range, or
	 * (b) file, line number, and line count. If the caller specifies both sets
	 * of information, the implementation should honor (b) and ignore (a).
	*/
	@Override
	public void retrieveDisassembly(BigInteger startAddress, BigInteger endAddress, String file, int lineNumber,
			int lines, boolean mixed, boolean showSymbols, boolean showDisassembly, int linesHint) {
		CDTDisassembleArguments args = new CDTDisassembleArguments();
		args.setMemoryReference("0x" + startAddress.toString(16)); //$NON-NLS-1$
		args.setInstructionCount(lines);
		args.setEndMemoryReference("1+0x" + endAddress.toString(16)); //$NON-NLS-1$
		CompletableFuture<DisassembleResponse> future = dspStackFrame.getDebugProtocolServer().disassemble(args);
		future.thenAcceptAsync(res -> {
			fCallback.asyncExec(() -> insertDisassembly(startAddress, endAddress, res, showSymbols, showDisassembly));
		});
	}

	/**
	 * @param startAddress
	 *            an address the caller is hoping will be covered by this
	 *            insertion. I.e., [mixedInstructions] may or may not contain
	 *            that address; the caller wants to know if it does, and so we
	 *            indicate that via our return value. Can be null to indicate n/a,
	 *            in which case we return true as long as any instruction was inserted
	 *            as long as any instruction was inserted
	 * @param endAddress
	 *            cut-off address. Any elements in [mixedInstructions] that
	 *            extend beyond this address are ignored.
	 * @param mixedInstructions
	 * @param showSymbols
	 * @param showDisassembly
	 * @return whether [startAddress] was inserted
	 */
	private void insertDisassembly(BigInteger startAddress, BigInteger endAddress, DisassembleResponse response,
			boolean showSymbols, boolean showDisassembly) {
		if (!fCallback.hasViewer() || dspStackFrame == null) {
			if (DEBUG) {
				System.out.println(
						MessageFormat.format("insertDisassembly ignored at {0} : missing context: [dspStackFrame={1}]", //$NON-NLS-1$
								DisassemblyUtils.getAddressText(startAddress), dspStackFrame));
			}
			if (dspStackFrame == null) {
				fCallback.setUpdatePending(false);
			}
			return;
		}
		if (DEBUG)
			System.out.println("insertDisassembly " + DisassemblyUtils.getAddressText(startAddress)); //$NON-NLS-1$
		boolean updatePending = fCallback.getUpdatePending();
		assert updatePending;
		if (!updatePending) {
			// safe-guard in case something weird is going on
			return;
		}

		boolean insertedAnyAddress = false;
		try {
			fCallback.lockScroller();

			AddressRangePosition p = null;
			Source location = null;
			DisassembledInstruction[] instructions = response.getInstructions();
			for (int i = 0; i < instructions.length; ++i) {
				DisassembledInstruction instruction = instructions[i];
				if (instruction.getLocation() != null) {
					location = instruction.getLocation();
				}
				assert location != null;
				String file = null;
				if (location != null) {
					file = location.getPath();
				}
				Integer line = instruction.getLine();
				int lineNumber = (line == null ? 0 : line.intValue()) - 1;
				BigInteger address = getAddress(instruction);
				if (startAddress == null) {
					startAddress = address;
					fCallback.setGotoAddressPending(address);
				}
				if (p == null || !p.containsAddress(address)) {
					p = fCallback.getPositionOfAddress(address);
				}
				if (p instanceof ErrorPosition && p.fValid) {
					p.fValid = false;
					fCallback.getDocument().addInvalidAddressRange(p);
				} else if (p == null || address.compareTo(endAddress) > 0) {
					if (DEBUG)
						System.out.println("Excess disassembly lines at " + DisassemblyUtils.getAddressText(address)); //$NON-NLS-1$
					return;
				} else if (p.fValid) {
					if (DEBUG)
						System.out.println("Excess disassembly lines at " + DisassemblyUtils.getAddressText(address)); //$NON-NLS-1$
					if (!p.fAddressOffset.equals(address)) {
						// override probably unaligned disassembly
						p.fValid = false;
						fCallback.getDocument().addInvalidAddressRange(p);
					} else {
						continue;
					}
				}
				boolean hasSource = false;
				if (file != null && lineNumber >= 0) {
					p = fCallback.insertSource(p, address, file, lineNumber);
					hasSource = fCallback.getStorageForFile(file) != null;
				}
				// insert symbol label
				String functionName;
				int offset;
				String symbol = instruction.getSymbol();
				if (symbol != null) {
					String[] split = symbol.split("\\+", 2); //$NON-NLS-1$
					functionName = split[0];
					if (split.length > 1) {
						try {
							offset = Integer.parseInt(split[1]);
						} catch (NumberFormatException e) {
							offset = 0;
						}
					} else {
						offset = 0;
					}
				} else {
					functionName = null;
					offset = 0;
				}
				if (functionName != null && !functionName.isEmpty() && offset == 0) {
					p = fCallback.getDocument().insertLabel(p, address, functionName,
							showSymbols && (!hasSource || showDisassembly));
				}
				// determine instruction byte length
				BigInteger instrLength = null;
				if (i < instructions.length - 1) {
					instrLength = getAddress(instructions[i + 1]).subtract(address).abs();
				} else {
					// cannot determine length of last instruction
					break;
				}
				String funcOffset = instruction.getSymbol();
				if (funcOffset == null) {
					funcOffset = ""; //$NON-NLS-1$
				}

				BigInteger opCodes = null;
				if (instruction.getInstructionBytes() != null) {
					opCodes = new BigInteger(instruction.getInstructionBytes().replace(" ", ""), 16); //$NON-NLS-1$//$NON-NLS-2$
				}

				p = fCallback.getDocument().insertDisassemblyLine(p, address, instrLength.intValue(), funcOffset,
						opCodes, instruction.getInstruction(), file, lineNumber);
				if (p == null) {
					break;
				}
				insertedAnyAddress = true;

			}

		} catch (BadLocationException e) {
			// should not happen
			DisassemblyUtils.internalError(e);
		} finally {
			fCallback.setUpdatePending(false);
			if (insertedAnyAddress) {
				fCallback.updateInvalidSource();
				fCallback.unlockScroller();
				fCallback.doPending();
				fCallback.updateVisibleArea();
			} else {
				fCallback.unlockScroller();
			}
		}
	}

	private BigInteger getAddress(DisassembledInstruction instruction) {
		if (instruction.getAddress().startsWith("0x")) { //$NON-NLS-1$
			return new BigInteger(instruction.getAddress().substring(2), 16);
		} else {
			return new BigInteger(instruction.getAddress(), 10);
		}
	}

	@Override
	public Object insertSource(Position pos, BigInteger address, String file, int lineNumber) {
		ISourceLookupDirector lookupDirector = getSourceLookupDirector();
		return lookupDirector.getSourceElement(file);
	}

	private ISourceLookupDirector getSourceLookupDirector() {
		if (dspStackFrame == null) {
			return null;
		}
		DSPDebugTarget debugTarget = dspStackFrame.getDebugTarget();
		if (debugTarget == null) {
			return null;
		}
		ILaunch launch = debugTarget.getLaunch();
		if (launch == null) {
			return null;
		}
		ISourceLocator sourceLocator = launch.getSourceLocator();
		if (sourceLocator instanceof ISourceLookupDirector) {
			ISourceLookupDirector lookupDirector = (ISourceLookupDirector) sourceLocator;
			return lookupDirector;
		}
		return null;
	}

	@Override
	public void gotoSymbol(String symbol) {
		String.class.getClass();

	}

	@Override
	public void retrieveDisassembly(String file, int lines, BigInteger endAddress, boolean mixed, boolean showSymbols,
			boolean showDisassembly) {
		String.class.getClass();

	}

	@Override
	public String evaluateExpression(String expression) {
		CompletableFuture<IVariable> evaluate = dspStackFrame.evaluate(expression);
		try {
			IVariable iVariable = evaluate.get();
			return iVariable.getValue().getValueString();
		} catch (InterruptedException e) {
			return null;
		} catch (ExecutionException | DebugException | NumberFormatException e) {
			return null;
		}
	}

	@Override
	public void dispose() {
		String.class.getClass();

	}

	@Override
	protected void handleError(IStatus status) {
		Activator.log(status);
	}

	@Override
	public BigInteger evaluateAddressExpression(String expression, boolean suppressError) {
		CompletableFuture<IVariable> evaluate = dspStackFrame.evaluate(expression);
		try {
			IVariable variable = evaluate.get();
			return DisassemblyUtils.decodeAddress(variable.getValue().getValueString());
		} catch (InterruptedException e) {
			Thread.currentThread().interrupt();
			return null;
		} catch (ExecutionException | DebugException | NumberFormatException e) {
			if (!suppressError) {
				DapDisassemblyBackend.this.handleError(new Status(IStatus.ERROR, Activator.PLUGIN_ID, 0,
						"Expression does not evaluate to an address (" //$NON-NLS-1$
								+ e.getMessage() + ")", //$NON-NLS-1$
						null));
			}
			return null;
		}

	}
}