package acl2s.plugin.editors;
	
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.ITextViewer;
	import org.eclipse.jface.text.contentassist.CompletionProposal;
	import org.eclipse.jface.text.contentassist.ContextInformation;
	import org.eclipse.jface.text.contentassist.ContextInformationValidator;
	import org.eclipse.jface.text.contentassist.ICompletionProposal;
	import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
	import org.eclipse.jface.text.contentassist.IContextInformation;
	import org.eclipse.jface.text.contentassist.IContextInformationValidator;
	
	import acl2s.lib.contentassist.*;
	import acl2s.lib.contentassist.FileDictionary.CharacterTreeFindResult;
	import acl2s.lib.parse.Parser;
	import acl2s.lib.session.IResultInfo;
	import acl2s.lib.session.SessionException;
	import acl2s.plugin.Acl2sPlugin;
	import acl2s.plugin.editors.lisp.LispDocument;
	import acl2s.plugin.parse.LispToken;
	import acl2s.plugin.parse.LispTokens;
	import acl2s.uilib.session.InteractiveSessionManager;
	
	public class LispCompletionProcessor implements IContentAssistProcessor {
		private final char[] PROPOSAL_ACTIVATION_CHARS = new char[] { '(', ':' };
		private String lastExceptionMessage;
		private IContextInformationValidator validator;
		private final boolean useContext = false;
	
		public LispCompletionProcessor() {
			lastExceptionMessage = "";
			getContextInformationValidator();
		}
	
		private CharacterTreeFindResult getFunParams(String prefix,
				LispDocument doc, int offset, List<String> completions) {
			LispTokens toks = doc.getTokens();
			// head backwards to first defun or defmacro or name of an indexed macro
			LispToken t = null;
			int offs = offset, ind = 0;
			do {
				ind = toks.prevSexpToken(offs);
				t = toks.getToken(ind);
				offs = t.offset;
	
				try {
					String sym = (t.type == LispToken.SYM_TOK) ? doc.get(t.offset,
							t.length) : null;
	
					if (sym != null) {
						t = toks.getToken(ind + 1);
						String name = doc.get(t.offset, t.length);
						CharacterTreeFindResult r = WorkspaceDictionary.findExact(
								doc, name,
								FileDictionary.CharacterTreeNodeType.FUNTYPE);
						if (r != null) {
							for (String s : r.signature) {
								if (s != null && s.toLowerCase().startsWith(prefix)
										&& !completions.contains(s))
									completions.add(s);
							}
							return r; // function name
						}
					}
				} catch (BadLocationException ble) {
					return null;
				} catch (IndexOutOfBoundsException iob) {
					// fine, just continue
				}
			} while (t != null && offs > 0 && t.ctx != null);
			return null;
		}
	
		private void getLetBindings(String prefix, LispDocument doc, int offset,
				List<String> completions) {
			LispTokens toks = doc.getTokens();
			// head backwards to each let and then add the bindings that match the
			// prefix.
			// (let ((name symbol) (name2 (sexp))) ...)
			LispToken t = null, n = null, m = null;
			int offs = offset, ind = 0;
			boolean let = false;
			do {
				ind = toks.prevSexpToken(offs);
				t = toks.getToken(ind);

				offs = t.offset;
	
				try {

					String sym = (t.type == LispToken.SYM_TOK) ? doc.get(t.offset,
							t.length) : null;
	

					let = sym != null
							&& (sym.equalsIgnoreCase("let")
									|| sym.equalsIgnoreCase("let*") || sym
									.equalsIgnoreCase("letrec"));

					if (let) {
						let = true;
						// get to first symbol
						while ((n = toks.getToken(ind + 1)).type == LispToken.OPAREN_TOK)
							++ind;
						// add first completion
						if (n != null && n.type == LispToken.SYM_TOK) {
							sym = doc.get(n.offset, n.length);
							if (sym.toLowerCase().startsWith(prefix.toLowerCase())
									&& !completions.contains(sym))
								completions.add(sym);
						}
						m = toks.getToken(ind);
						while (m.type != LispToken.CPAREN_TOK) {
							ind = toks.nextSexpToken(m.offset);
							m = toks.getToken(ind);
							if (m.type == LispToken.OPAREN_TOK
									&& (n = toks.getToken(ind + 1)).type == LispToken.SYM_TOK) {
								sym = doc.get(n.offset, n.length);
								if (sym.toLowerCase().startsWith(
										prefix.toLowerCase())
										&& !completions.contains(sym))
									completions.add(sym);
							}
						}
					}
				} catch (BadLocationException ble) {
					return;
				} catch (IndexOutOfBoundsException iob) {
					// fine, just continue
				}

			} while (t != null && offs > 0 && t.ctx != null);
		}
	
		private void addContextDocType(String prefix, LispDocument document,
				FileDictionary.CharacterTreeNodeType type,
				ArrayList<String> completions,
				ArrayList<IContextInformation> contexts) {
			String typeString;
			ArrayList<CharacterTreeFindResult> dictFind = WorkspaceDictionary.find(
					document, prefix, type);
			for (int i = 0; i < dictFind.size(); ++i) {
				CharacterTreeFindResult res = dictFind.get(i);
				if (!completions.contains(res.symbol)) {
					typeString = "";
					completions.add(res.symbol);
					if (useContext) {
						switch (res.type) {
						case DEFMACRO: {
							if (res.signature != null && res.signature.length != 0) {
								StringBuffer sb = new StringBuffer(res.signature[0]);
								for (int j = 1; j < res.signature.length; ++j)
									sb.append(" ").append(res.signature[j]);
								typeString = String.format(
										"(defmacro %s (%s) ...)", res.symbol, sb);
							} else {
								typeString = String.format("(defmacro %s () ...)",
										res.symbol);
							}
						}
							break;
						case DEFUN: {
							if (res.signature != null && res.signature.length != 0) {
								StringBuffer sb = new StringBuffer(res.signature[0]);
								for (int j = 1; j < res.signature.length; ++j)
									sb.append(" ").append(res.signature[j]);
								typeString = String.format("(defun %s (%s) ...)",
										res.symbol, sb);
							} else {
								typeString = String.format("(defun %s () ...)",
										res.symbol);
							}
						}
							break;
						case DEFCONST: {
							typeString = "defconst";
						}
							break;
						case DEFTHM: {
							typeString = "defthm";
						}
							break;
						}
						contexts.add(new ContextInformation(Acl2sPlugin
								.getImage("icons/f_blue.gif"), res.symbol,
								typeString));
					}
				}
			}
		}
	
		public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer,
				int offset) {
			ArrayList<String> completions = new ArrayList<String>();
			ArrayList<IContextInformation> contexts = new ArrayList<IContextInformation>();
			LispToken tok = computeCompletionsAndInfo(viewer, offset, completions,
					contexts);
	
			if (tok == null)
				return null;
	
			ICompletionProposal[] results = new CompletionProposal[completions
					.size()];
			Iterator<String> itr = completions.iterator();
			Iterator<IContextInformation> citr = contexts.iterator();
			int i = 0;
			while (itr.hasNext()) {
				String replace = itr.next();
				results[i] = new CompletionProposal(replace, tok.offset,
						tok.length, replace.length());
				if (useContext) {
					IContextInformation info = citr.next();
					getContextInformationValidator().install(info, viewer,
							tok.offset);
				}
				++i;
			}
			return results;
		}
	
		public IContextInformation[] computeContextInformation(ITextViewer viewer,
				int offset) {
			ArrayList<String> completions = new ArrayList<String>();
			ArrayList<IContextInformation> contexts = new ArrayList<IContextInformation>();
			computeCompletionsAndInfo(viewer, offset, completions, contexts);
			return contexts.toArray(new ContextInformation[contexts.size()]);
		}
	
		private LispToken computeCompletionsAndInfo(ITextViewer viewer, int offset,
				ArrayList<String> completions,
				ArrayList<IContextInformation> contexts) {
			try {
				LispDocument document = (LispDocument) viewer.getDocument();
				LispTokens toks = document.getTokens();
				int tokInd = toks.getTokenIdxContaining(offset - 1);
				LispToken tok = toks.getToken(tokInd);
				if (tok.absoluteEnd() < offset - 1 || tok.type != LispToken.SYM_TOK)
					return null;
	
				// need to know if this is a function, command or variable.
				// '(', ':', ' ' respective previous characters. '\0' if no prev
				// char (no completions)
				char tokPrevChar = (tok.offset != 0) ? document
						.getChar(tok.offset - 1) : ' ';
				if (tokInd > 0) {
					LispToken prevTok = toks.getToken(tokInd - 1);
					if (prevTok.type == LispToken.OPAREN_TOK)
						tokPrevChar = '(';
					else if (tokPrevChar != ':')
						tokPrevChar = ' ';
				}
	
				String prefix = document.get(tok.offset, tok.length);
				String prefixfixed = (prefix.startsWith("|")) ? prefix : prefix
						.toUpperCase();
				int fromInd = 0;
	
				switch (tokPrevChar) {
				case '(': {
					// TODO First add functions in local context
	
					// Next add functions in file (don't care if it's defined after
					// this line. Not our problem)
					addContextDocType(prefix, document,
							FileDictionary.CharacterTreeNodeType.FUNTYPE,
							completions, contexts);
					// Next add functions in base ACL2 definition
					addContextDocType(prefix, null,
							FileDictionary.CharacterTreeNodeType.FUNTYPE,
							completions, contexts);
					fromInd = completions.size();
	
					// add functions that exist in the open session
					try {
						InteractiveSessionManager manager = document.getSession()
								.getManager();
						if (manager.isAlive()) {
							IResultInfo r = manager
									.systemCmd2("(acl2s::events-with-prefix \""
											+ prefixfixed
											+ "\" (acl2::w acl2::state) 'DEFUN)");
							Parser.parseListOfSymbols(r.getOutput(), completions, 0);
							if (useContext) {
							for (int i = fromInd; i < completions.size(); ++i) {
								contexts.add(new ContextInformation(completions
										.get(i), "ACL2 Session defun"));
							}
							fromInd = completions.size();
							}
	
							r = manager.systemCmd2("(acl2s::events-with-prefix \""
									+ prefixfixed
									+ "\" (acl2::w acl2::state) 'DEFMACRO)");
							Parser.parseListOfSymbols(r.getOutput(), completions, 0);
							if (useContext) {
							for (int i = fromInd; i < completions.size(); ++i) {
								contexts.add(new ContextInformation(completions
										.get(i), "ACL2 Session defmacro"));
							}
							}
						}
					} catch (SessionException sde) {
						// fine
					}
				}
					break;
				case ':': // possible commands (context-specific)
					// TODO Complete
					break;
				case ' ': // local let bindings and parameters (context-specific) or
							// defconsts
				{
					// First add the function (or macro) parameters
					CharacterTreeFindResult funname = getFunParams(prefix,
							document, offset, completions);
					if (useContext) {
						StringBuilder sb = new StringBuilder(
								String
										.format(
												"(%s ",
												(funname.type == FileDictionary.CharacterTreeNodeType.DEFUN ? "defun"
														: "defmacro")));
						for (int i = 0; i < completions.size(); ++i) {
							if (i != 0) {
								sb.append(' ');
							}
							sb.append(completions.get(i));
						}
						sb.append(')');
						
						for (int i = fromInd; i < completions.size(); ++i) {
							contexts.add(new ContextInformation(completions.get(i),
									String.format("Parameter of %s", sb)));
						}
						fromInd = completions.size();
					}
	
					// Next add the let bindings (deep to shallow)
					getLetBindings(prefix, document, offset, completions);
					if (useContext) {
						for (int i = fromInd; i < completions.size(); ++i) {
							contexts.add(new ContextInformation(completions.get(i),
									"Let binding"));
						}
					}
					fromInd = completions.size();
	
					// Next add the defconsts
					addContextDocType(prefix, document,
							FileDictionary.CharacterTreeNodeType.DEFCONST,
							completions, contexts);
	
					// Next add the defconsts in the base ACL2 session
					addContextDocType(prefix, null,
							FileDictionary.CharacterTreeNodeType.DEFCONST,
							completions, contexts);
					fromInd = contexts.size();
	
					// finally add defconsts that exist in the open session
					try {
						InteractiveSessionManager manager = document.getSession()
								.getManager();
						if (manager.isAlive()) {
							IResultInfo r = manager
									.systemCmd2("(acl2s::constants-with-prefix \""
											+ prefix.toUpperCase()
											+ "\" (acl2::w acl2::state))");
							Parser.parseListOfSymbols(r.getOutput(), completions, 0);
							if (useContext) {
								for (int i = fromInd; i < completions.size(); ++i) {
									contexts.add(new ContextInformation(completions
											.get(i), "ACL2 Session defconst"));
								}
							}
						}
					} catch (SessionException sbe) {
						// fine
					}
				}
					break;
				default:
					break;
				}
				return tok;
			} catch (Exception e) {
				contexts.clear();
				completions.clear();
				lastExceptionMessage = e.getMessage();
			}
			return null;
		}
	
		public char[] getCompletionProposalAutoActivationCharacters() {
			return PROPOSAL_ACTIVATION_CHARS;
		}
	
		public char[] getContextInformationAutoActivationCharacters() {
			return PROPOSAL_ACTIVATION_CHARS;
		}
	
		public IContextInformationValidator getContextInformationValidator() {
			if (useContext) {
				if (validator == null) {
					validator = new ContextInformationValidator(this);
				}
				return validator;
			}
			return null;
		}
	
		public String getErrorMessage() {
			return lastExceptionMessage;
		}
	
	}