package acl2s.plugin.editors;
	
	import java.io.File;
	import java.util.ArrayList;
	import java.util.Iterator;
	
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.Document;
	import org.eclipse.jface.text.IRegion;
	import org.eclipse.jface.text.source.Annotation;
	import org.eclipse.jface.text.source.AnnotationModel;
	import org.eclipse.jface.text.source.IAnnotationModel;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.text.undo.DocumentUndoManagerRegistry;
	import org.eclipse.text.undo.IDocumentUndoManager;
	import org.eclipse.ui.IEditorInput;
	import org.eclipse.ui.IFileEditorInput;
	import org.eclipse.ui.IPathEditorInput;
	import org.eclipse.ui.IURIEditorInput;
	import org.eclipse.ui.texteditor.ResourceMarkerAnnotationModel;
	
	import acl2s.lib.contentassist.WorkspaceDictionary;
	import acl2s.plugin.Acl2sPlugin;
	import acl2s.plugin.indent.DefaultLispIndent;
	import acl2s.plugin.indent.ILispIndent;
	import acl2s.plugin.parse.LispToken;
	import acl2s.plugin.parse.LispTokens;
	
	
	public abstract class A2sDocument extends Document {
		protected final Display display = Display.getDefault();
		
		protected LispTokens tokens;
		protected MyDocumentProvider dp;
		protected IEditorInput input = null;
		protected AnnotationModel annotations = null;
		protected String[] eols = null;
		protected boolean startedDirty = false;
		protected ILispIndent indent = null;
		
		protected A2sDocument(MyDocumentProvider dp) {
			super();
			this.dp = dp;
			annotations = new AnnotationModel();
			WorkspaceDictionary.addFile(this, null);
		}
		
		public IPath getOSPath() {
			if (input instanceof IFileEditorInput) {
				return ((IFileEditorInput)input).getFile().getLocation();
			} else if (input instanceof IPathEditorInput) {
				return ((IPathEditorInput)input).getPath();
			} else if (input instanceof IURIEditorInput) {
				try {
					return new Path(new File(((IURIEditorInput)input).getURI()).getAbsolutePath());
				} catch (IllegalArgumentException e) {
					return null;
				}
			} else {
				return null;
			}
		}
		
		public File getOSFile() {
			if (input instanceof IFileEditorInput) {
				return ((IFileEditorInput)input).getFile().getLocation().toFile();
			} else if (input instanceof IPathEditorInput) {
				return ((IPathEditorInput)input).getPath().toFile();
			} else if (input instanceof IURIEditorInput) {
				try {
					return new File(((IURIEditorInput)input).getURI());
				} catch (IllegalArgumentException e) {
					return null;
				}
			} else {

				return null;
			}
		}
		
		public IEditorInput getInput() { return input; }
		
		@SuppressWarnings("unchecked") // stupid Eclipse API
		public void setInput(IEditorInput i) {
			input = i;
			if (i instanceof IFileEditorInput) {
				AnnotationModel old = annotations;
				annotations = new ResourceMarkerAnnotationModel(((IFileEditorInput)i).getFile());
				Iterator<Annotation> foo = old.getAnnotationIterator();
				while (foo.hasNext()) {
					Annotation a = foo.next();
					annotations.addAnnotation(a,old.getPosition(a));
				}
			}
			eols = getLegalLineDelimiters();
			indent = new DefaultLispIndent(tokens, this);
		}
		
		public abstract MyDocumentProvider getProvider();
		
		public void ensureDirty() {
			if (input != null) {
				getProvider().setCanSaveDocument(input);
			} else {
				startedDirty = true;
			}
		}
		
		public boolean startedDirty() { return startedDirty; }
		
		public boolean isDirty() {
			return getProvider().canSaveDocument(input);
		}
		
		
		public IDocumentUndoManager getUndoManager() {
			return DocumentUndoManagerRegistry.getDocumentUndoManager(this);
		}
		
		public void resetUndoStuff() {
			IDocumentUndoManager m = getUndoManager();
			if (m != null) m.reset();
		}
		
		
		public boolean isEOL(String txt) {
			for (String s : eols) {
				if (s.equals(txt)) {
					return true;
				}
			}
			return false;
		}
		
		public String get2(int offset, int len) {
			try {
				return get(offset,len);
			} catch (BadLocationException e) {
				Acl2sPlugin.logError("Bad document location.",e);
				return "";
			}
		}
	
		public char getChar2(int i) {
			try {
				return getChar(i);
			} catch (BadLocationException e) {
				Acl2sPlugin.logError("Bad document location.",e);
				return '\0';
			}
		}
	
		public void replace2(int offset, int len, String s) {
			try {
				replace(offset,len,s);
			} catch (BadLocationException e) {
				Acl2sPlugin.logError("Bad document location.",e);
			}
		}
	
	
		
		public void replace(int pos, int length, String text) throws BadLocationException {
			if (text == null) text = "";  // Eclipse will actually call with null in places!!!
	
			if (allowReplace(pos, length, text)) {
				super.replace(pos, length, text);
			}
		}
	
		protected boolean allowReplace(int pos, int length, String text) {
			return pos >= readOnlyPoint();
		}
		
		public abstract int readOnlyPoint();
		
		public LispTokens getTokens() { return tokens; }
	
		public IAnnotationModel getAnnotationModel() {
			return annotations;
		}
		
		/* ***************  INDENT ************* */
		
		public ILispIndent getIndentStrategy() { return indent; }
		
		public void indentRegion(IRegion region) {
			try {
				int start = region.getOffset();
				int end = start + region.getLength();
				start = Math.max(start,readOnlyPoint());
				if (end > start) {
					end--;
				} else if (end < start) {
					return;
				}
				int firstLine = getLineOfOffset(start);
				int lastLine = getLineOfOffset(end);
				for (int i = firstLine; i <= lastLine; i++) {
					indent.indentLine(i);
				}
			} catch (BadLocationException e) {
				e.printStackTrace();
			}
		}
	
	
		
		/* ======= Sexp navigation/selection ======== */
		public int fwdToplevelSexp(int fromOffset) {
			int tIdx = tokens.getTokenIdxContaining(fromOffset);
			LispToken tok = tokens.getToken(tIdx);
			if (tok.ctx == null && tok.offset > fromOffset) {
				return tok.offset;
			}
			for (;;) {
				tIdx++;
				if (tIdx >= tokens.getTokenCount()) break;
				tok = tokens.getToken(tIdx);
				if (tok.ctx == null) break;
			}
			return tok.offset;
		}
	
		public int backToplevelSexp(int fromOffset) {
			int tIdx = tokens.getTokenIdxContaining(fromOffset);
			LispToken tok = tokens.getToken(tIdx);
			if (tok.ctx == null && tok.offset > fromOffset) {
				tIdx--;
			}
			for (;;) {
				if (tIdx < 0) break;
				tok = tokens.getToken(tIdx);
				if (tok.ctx == null) break;
				tIdx--;
			}
			return tok.offset;
		}
	
	
		
		/* ====== Description Notification ====== */
		protected abstract String doGetDescription();
		
		protected final ArrayList<IDescriptionListener> descListeners = new ArrayList<IDescriptionListener>();
	
		public void addDescriptionListener(IDescriptionListener l) {
			if (!descListeners.contains(l)) {
				descListeners.add(l);
				updateDescriptions();
			}
		}
		
		public void removeDescriptionListener(IDescriptionListener l) {
			descListeners.remove(l);
		}
		
		protected void updateDescriptions() {
			String desc = doGetDescription();
			for (IDescriptionListener l : descListeners) {
				l.descriptionChanged(desc);
			}
		}
		
		
	}