package acl2s.lib.session;
	
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileWriter;
	import java.io.IOException;
	import java.util.ArrayList;
	
	import javax.xml.parsers.ParserConfigurationException;
	import javax.xml.parsers.SAXParserFactory;
	
	import org.peterd.util.io.StreamCopier;
	import org.xml.sax.Attributes;
	import org.xml.sax.SAXException;
	import org.xml.sax.helpers.DefaultHandler;
	
	import acl2s.lib.parse.IParseContext;
	import acl2s.lib.parse.ParseException;
	import acl2s.lib.parse.StringParser;
	import acl2s.lib.parse.obj.Cons;
	import acl2s.lib.parse.obj.LispObject;
	import acl2s.lib.parse.obj.Sym;
	import acl2s.lib_driver.IAcl2sLibErrorHandler;
	
	public class ModeDir {
		protected final Sym includeBookDirSym;
		protected final File home;
		protected final Sym[] deps;
		protected final File[] certOrder;
		protected final SessionMode[] modes;
		protected final String addIncludeBookDirString;
		
		ModeDir(File home, Sym includeBookDirSym, Sym[] deps, File[] certOrder, SessionMode[] modes) {
			if (certOrder == null) certOrder = new File[] {};
			this.certOrder = certOrder;
			if (deps == null) deps = new Sym[] {};
			this.deps = deps;
			this.home = home;
			this.includeBookDirSym = includeBookDirSym;
			if (modes == null) modes = new SessionMode[] {};
			this.modes = modes;
			this.addIncludeBookDirString =
				includeBookDirSym == null ? "" :
					"(acl2::add-include-book-dir " + includeBookDirSym.toString() +
					" \"" + MyBaseConfig.toAcl2PathDir(home) + "\")\n";
		}
	
		public Sym getIncludeBookDirSym() {
			return includeBookDirSym;
		}
	
		public File getHome() {
			return home;
		}
	
		public Sym[] getDeps() {
			return deps;
		}
	
		public File[] getCertOrder() {
			return certOrder;
		}
	
		public SessionMode[] getModes() {
			return modes;
		}
	
		public String getAddIncludeBookDirString() {
			return addIncludeBookDirString;
		}
		
		
		void maybeWriteDirLsp() {
			File dirLsp = new File(home, "dir.lsp");
			if (!dirLsp.exists() || dirLsp.canWrite()) {
				try {
					FileWriter w = new FileWriter(dirLsp);
					w.append(addIncludeBookDirString);
					w.close();
				} catch (IOException e) {
					// ignore
				}
			}
		}
		
		static final IParseContext bootstrappc = BootstrapParseContext.instance;
		static final IParseContext keywordpc = BootstrapParseContext.keywordParseInstance;
	
		static class ModeDirParser extends DefaultHandler {
			protected IAcl2sLibErrorHandler err;
			protected File dir;
			protected String msgPrefix;
			
			ModeDirParser(IAcl2sLibErrorHandler err, File dir) {
				this.err = err;
				this.dir = dir;
				this.msgPrefix = "While parsing plugin.xml for mode dir " + dir.getAbsolutePath() + ":\n";
			}
			
			protected Sym includeBookDir;
			protected final ArrayList<Sym> deps = new ArrayList<Sym>();
			protected final ArrayList<File> order = new ArrayList<File>();
			protected final ArrayList<SessionMode> modes = new ArrayList<SessionMode>();
			
			boolean inExtension = false;
	
			@Override
			public void startElement(String uri, String localName, String name, Attributes attributes)
			throws SAXException {

				if (inExtension) {

					if (name.equals("include-book-dir-entry")) {
						int len = attributes.getLength();
						for (int i = 0; i < len; i++) {
							if (attributes.getQName(i).equals("keyword")) {
								String val = attributes.getValue(i);
								try {
									includeBookDir = Sym.parse(new StringParser(keywordpc, val));
									if (!includeBookDir.isKeyword()) {
										err.error("include-book-dir-entry must be a keyword symbol", null);
										includeBookDir = null;
									}
								} catch (ParseException e) {
									err.error("Malformed include-book-dir-entry", e);
								}
							}
						}
						return;
					}

					if (name.equals("certify-order-element")) {
						int len = attributes.getLength();
						for (int i = 0; i < len; i++) {
							if (attributes.getQName(i).equals("book")) {
								String val = attributes.getValue(i);
								String cpath = MyBaseConfig.toSystemPathString(val + ".lisp");
								
								File f = new File(dir, cpath);
								if (f.canRead()) {
									order.add(f);
								} else {
									err.error(msgPrefix + "certify-order-element book does not exist: " + val + " (" + cpath + ")", null);
								}
							}
						}
						return;
					}

					if (name.equals("dependency")) {
						int len = attributes.getLength();
						for (int i = 0; i < len; i++) {
							if (attributes.getQName(i).equals("keyword")) {
								String val = attributes.getValue(i);
								try {
									Sym d = Sym.parse(new StringParser(keywordpc, val));
									if (d.isKeyword()) {
										deps.add(d);
									} else {
										err.error(msgPrefix + "include-book-dir-entry must be a keyword symbol", null);
									}
								} catch (ParseException e) {
									err.error(msgPrefix + "Malformed include-book-dir-entry", e);
								}
							}
						}
						return;
					}

					if (name.equals("mode")) {
						String mname = null;
						String sdesc = null;
						String ldesc = null;
						boolean bookdev = true;
						boolean introductory = false;
						LispObject ttags = Sym.nilInstance;
						LispObject extraImports = Sym.nilInstance;
						int precedence = 500;
						String initData = "";
						
						int len = attributes.getLength();

						for (int i = 0; i < len; i++) {
							String aname = attributes.getQName(i);
							String val = attributes.getValue(i);

							if (aname.equals("name")) {
								mname = val;

							} else if (aname.equals("short_desc")) {
								sdesc = val;

							} else if (aname.equals("long_desc")) {
								ldesc = val;

							} else if (aname.equals("book_dev")) {
								bookdev = Boolean.parseBoolean(val);

							} else if (aname.equals("ttags")) {
								try {
									ttags = LispObject.parseOne(new StringParser(bootstrappc, val));
								} catch (ParseException e) {
									err.error(msgPrefix + "Malformed ttags spec for mode", e);
								}

							} else if (aname.equals("introductory")) {
								introductory = Boolean.parseBoolean(val);

							} else if (aname.equals("extra_imports")) {
								try {
									extraImports = LispObject.parseOne(new StringParser(bootstrappc, val));
									extraImports = Cons.maybeDeQuote(extraImports);
	

									if (extraImports.isNotNil()) {
										extraImports = Cons.quote(extraImports);
									}
								} catch (ParseException e) {
									err.error(msgPrefix + "Malformed ttags spec for mode", e);
								}

							} else if (aname.equals("precedence")) {
								try {

									precedence = Integer.parseInt(val);

								} catch (NumberFormatException e) {
									err.error(msgPrefix + "Malformed precedence for mode", e);
								}

							} else if (aname.equals("init_file")) {
								val = MyBaseConfig.toSystemPathString(val);
								File initFile = new File(dir,val);
								try {

									FileInputStream stream = new FileInputStream(initFile);

									initData = new String(StreamCopier.dump(stream));
									stream.close();

								} catch (IOException e) {
									err.error(msgPrefix + "Error reading init file " + initFile.getAbsolutePath(), e);
								}
							}
						}

						if (mname != null) {
							modes.add(new SessionMode(dir, mname, sdesc, ldesc, bookdev, ttags.isNotNil(), introductory, extraImports, precedence, new String[] {initData}));
						}

						return;
					}
				} else {
					if (name.equals("extension")) {
						int len = attributes.getLength();
						for (int i = 0; i < len; i++) {
							if (attributes.getQName(i).equals("point")) {
								if (attributes.getValue(i).equals("acl2s.modedir")) {
									inExtension = true;
									break;
								}
							}
						}
						return;
					}
				}
			}
	
			@Override
			public void endElement(String uri, String localName, String name)
					throws SAXException {
				if (localName.equals("extension")) {
					inExtension = false;
				}
			}
			
			public ModeDir go() {
				File pluginFile = new File(dir, "plugin.xml");
				ModeDir ret = null;
				try {
					saxFactory.newSAXParser().parse(pluginFile, this);
					ret = new ModeDir(dir,includeBookDir,
							deps.toArray(new Sym[deps.size()]),
							order.toArray(new File[order.size()]),
							modes.toArray(new SessionMode[modes.size()]));
				} catch (SAXException e) {
					err.error(msgPrefix + "Error parsing " + pluginFile.getAbsolutePath(), e);
				} catch (IOException e) {
					err.error(msgPrefix + "Error parsing " + pluginFile.getAbsolutePath(), e);
				} catch (ParserConfigurationException e) {
					err.error(msgPrefix + "Error parsing " + pluginFile.getAbsolutePath(), e);
				}
				if (ret != null) {
					ret.maybeWriteDirLsp();
				}
				return ret;
			}
		}
		
		public static ModeDir maybeCreate(IAcl2sLibErrorHandler err, File home) {
			return new ModeDirParser(err, home).go();
		}
		
		static SAXParserFactory saxFactory = SAXParserFactory.newInstance();
	}