package acl2s.uilib.cmd;
	
	import java.io.Serializable;
	import java.nio.ByteBuffer;
	import java.nio.CharBuffer;
	import java.nio.charset.Charset;
	import java.nio.charset.CharsetDecoder;
	import java.nio.charset.CharacterCodingException;
	import java.util.ArrayList;
	
	import org.peterd.util.Misc;
	
	import acl2s.lib.parse.EmptyParse;
	import acl2s.lib.parse.IParseContext;
	import acl2s.lib.parse.ParseException;
	import acl2s.lib.parse.Parser;
	import acl2s.lib.parse.PositionableParser;
	import acl2s.lib.parse.StringParser;
	import acl2s.lib.parse.obj.Atom;
	import acl2s.lib.parse.obj.Char;
	import acl2s.lib.parse.obj.Cons;
	import acl2s.lib.parse.obj.LispObject;
	import acl2s.lib.parse.obj.NotListException;
	import acl2s.lib.parse.obj.Num;
	import acl2s.lib.parse.obj.ReadTimeConditional;
	import acl2s.lib.parse.obj.Str;
	import acl2s.lib.parse.obj.Sym;
	import acl2s.lib.session.SessionException;
	import acl2s.lib.session.SessionMode;
	import acl2s.plugin.ISessionDocument;
	import acl2s.plugin.prefs.InteractionPrefs;
	import acl2s.uilib.session.InteractiveSessionManager;
	
	public abstract class ResolvableUserInput implements Serializable {
		private static final long serialVersionUID = 3L;
		
		public abstract ResolvedInput resolve(InteractiveSessionManager session) throws SessionException;
		
		
		protected final String text;       // typed input (ish)
	
		protected final String source;
		
		public ResolvableUserInput(String text, String source) {
			this.text = text;
			this.source = source;
		}
		
		public String getInputString() {
			return text;
		}
	
		public String getSource() {
			return source;
		}
	
		public boolean equals(Object o) {
			if (o instanceof ResolvableUserInput) {
				ResolvableUserInput that = (ResolvableUserInput) o;
				return this.exactlyEquals(that);
			} else {
				return false;
			}
		}
		
		public boolean exactlyEquals(ResolvableUserInput that) {
			return (this.text).equals(that.text);
		}
		
		public boolean abstractlyEquals(ResolvableUserInput that, IParseContext pc) {
			LispObject[] thisLst = LispObject.robustParseAll(new StringParser(pc,this.text));
			LispObject[] thatLst = LispObject.robustParseAll(new StringParser(pc,that.text));
			if (thisLst.length != thatLst.length) return false;
			for (int i = 0; i < thisLst.length; i++) {
				if (!thisLst[i].equals(thatLst[i])) return false;
			}
			return true;
		}
		
		private static boolean isASCII(String text) {
			// Test text for non-ASCII characters
			byte [] bytearray = text.getBytes();
			CharsetDecoder d = Charset.forName("US-ASCII").newDecoder();
			try {
				CharBuffer r = d.decode(ByteBuffer.wrap(bytearray));
				r.toString();
			} catch (CharacterCodingException cce) {
				return false;
			}
			return true;
		}
		
		
		// CREATION/PARSING
		
		public static ResolvableUserInput parse(PositionableParser p, String source, ISessionDocument sesdoc) throws ParseException, BadCmdException {
			p.skipSpaceAndComments();
			if (p.peek() == Parser.EOF) throw new EmptyParse();
			int start = p.getPos();
			
			IParseContext pc = p.getContext();
			LispObject cmd = LispObject.parse(p);     // default: entire expression
			Boolean checkASCII = InteractionPrefs.getCheckASCII(null, sesdoc);
			SessionMode mode = (checkASCII == null && sesdoc != null) ? sesdoc.getAcl2Mode() : null;
			boolean mcheck = (mode == null) ? true : mode.getIntroductory();
			if ((checkASCII == null ? mcheck :
					checkASCII.booleanValue()) && 
				!isASCII(cmd.toString(pc))) {
				throw new BadCmdException("Input may not contain non-ASCII characters.");			
			}
			
			LispObject cond = null;  // default: unguarded
			if (cmd instanceof ReadTimeConditional) {
				ReadTimeConditional rtc = (ReadTimeConditional) cmd;
				cond = rtc.fexpr;
				cmd = rtc.oexpr;
			}
			
			String text = p.substring(start,p.getPos());
	
			if (cmd instanceof Sym) {
				Sym s = (Sym) cmd;
				if  (s.isKeyword()) { // keyword command
					if (cond != null) {
						throw new BadCmdException("Keyword commands preceded by read-time conditionals not supported.");
					}
					ArrayList<LispObject> params = new ArrayList<LispObject>();
					for (;;) {
						p.skip(true,false,true);
						char c = p.peek();
						if (c == '\n' || c == '\r' || c == Parser.EOF) break;
						params.add(LispObject.parseOne(p));
					}
					if (p.peek() == Parser.EOF) {
						throw new ParseException("Keyword command must be terminated by a newline outside of a lisp expression.");
					}
					text = p.substring(start,p.getPos());
					p.skip();
					return new UnresolvedKeywordCmd(text,s,params.toArray(new LispObject[params.size()]),source);
				}
			}
			
			if (((cmd instanceof Cons) || (cmd instanceof Num)) && text.charAt(text.length()-1) == ')') {
				// Cons or Complex ending in ) is fine
			} else {
				// need whitespace; Char ending in ) is NOT fine
				if ("\n\r\t\f ;".indexOf(p.peek()) < 0) {
					throw new ParseException("This form must be followed by whitespace, so that modifying text after it cannot change how it would be parsed.");
				}
				p.skip();
			}
			
			if (cmd instanceof Cons) {
				LispObject[] objs;
				try {
					objs = ((Cons) cmd).listToArray();
					if (objs == null || objs.length < 1) throw new NotListException();
				} catch (NotListException e) {
					throw new BadCmdException("Invocation must be a true list.");
				}
				if (!(objs[0] instanceof Sym)) {
					// old
					//throw new BadCmdException("First element of invocation list must be a symbol.");
				}
				
			} else if (cmd instanceof Atom && cond == null) {
				Atom a = (Atom) cmd;
				if (a instanceof Char || a instanceof Num) {
					return new SimpleValueInput(text, a, source);
				} else if (a instanceof Str) {
					Str s = (Str) a;

					if (!Misc.equal(s.value.toUpperCase(),s.value)) { // can't be a package name
						return new SimpleValueInput(text, a, source);
					}
					// strings with no lowercase letters could be VALUE or COMMAND
				}
				// syms could be BAD or VALUE
			}
			
			return new UnresolvedCmd(text,cmd,cond,source);
		}
	
		
	}