path: root/rosetta/src/main/java/org/onap/aaf/rosetta/InXML.java

/*******************************************************************************
 * ============LICENSE_START====================================================
 * * org.onap.aaf
 * * ===========================================================================
 * * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
 * * ===========================================================================
 * * Licensed under the Apache License, Version 2.0 (the "License");
 * * you may not use this file except in compliance with the License.
 * * You may obtain a copy of the License at
 * * 
 *  *      http://www.apache.org/licenses/LICENSE-2.0
 * * 
 *  * Unless required by applicable law or agreed to in writing, software
 * * distributed under the License is distributed on an "AS IS" BASIS,
 * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * * See the License for the specific language governing permissions and
 * * limitations under the License.
 * * ============LICENSE_END====================================================
 * *
 * * ECOMP is a trademark and service mark of AT&T Intellectual Property.
 * *
 ******************************************************************************/
package org.onap.aaf.rosetta;

import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;

import org.onap.aaf.inno.env.Env;
import org.onap.aaf.inno.env.TimeTaken;
import org.onap.aaf.rosetta.InXML.State;

public class InXML implements Parse<Reader, State> {
	// package on purpose
	JaxInfo jaxInfo;

	public InXML(JaxInfo jaxInfo) {
		this.jaxInfo = jaxInfo;
	}
	
	public InXML(Class<?> cls, String ... rootNs) throws SecurityException, NoSuchFieldException, ClassNotFoundException, ParseException {
		jaxInfo = JaxInfo.build(cls,rootNs);
	}


	// @Override
	public Parsed<State> parse(Reader r, Parsed<State> parsed) throws ParseException {
		State state = parsed.state;
		
		// OK, before anything else, see if there is leftover processing, if so, do it!
		if(state.unevaluated!=null) {
			DerTag dt = state.unevaluated;
			state.unevaluated = null;
			if(!state.greatExp.eval(parsed, dt))return parsed;
		}

		if(state.hasAttributes()) {
			Prop prop = state.pop();
			parsed.event = Parse.ATTRIB;
			parsed.name = prop.tag;
			parsed.sb.append(prop.value);
			parsed.isString=true;
			return parsed;
		}
		int ch;
		char c;
		boolean inQuotes = false, escaped = false;

		StringBuilder sb = parsed.sb, tempSB = new StringBuilder();
		boolean go = true;
		
		try {
			while(go && (ch=r.read())>=0) {
				c = (char)ch;
				if(c == '"') {
					if(state.greatExp instanceof LeafExpectations) { // within a set of Tags, make a Quote
						sb.append(c);
					} else {
						if(inQuotes) {
							if(escaped) {
								sb.append('\\');
								sb.append(c);
								escaped = false;
							} else {
								inQuotes = false;
							}
						} else {
							parsed.isString=true;
							inQuotes = true;
						}
					}
				} else if(inQuotes) {
					sb.append(c);
				} else if(c=='&') {
					XmlEscape.xmlEscape(sb,r);
				} else {
					switch(c) {
						case '<':
							DerTag tag=new DerTag().parse(r, tempSB);
							go = state.greatExp.eval(parsed, tag);
							break;
						default:
							// don't add Whitespace to start of SB... saves removing later
							if(sb.length()>0) {
								sb.append(c);
							} else if(!Character.isWhitespace(c)) { 
								sb.append(c);
							}
						}
				}
			}
			return parsed;
		} catch (IOException e) {
			throw new ParseException(e);
		}
	}
	
	public static final class DerTag {
		public String name;
		public boolean isEndTag;
		public List<Prop> props;
		private boolean isXmlInfo;
		//private String ns; 
		
		public DerTag() {
			name=null;
			isEndTag = false;
			props = null;
			isXmlInfo = false;
		}
		
		public DerTag parse(Reader r, StringBuilder sb) throws ParseException {
			int ch;
			char c;
			boolean inQuotes = false, escaped = false;
			boolean go = true;
			String tag = null;
			
			try {
				if((ch = r.read())<0) throw new ParseException("Reader content ended before complete");
				if(ch=='?') {
					isXmlInfo = true;
				}
				// TODO Check for !-- comments
				do {
					c=(char)ch;
 					if(c=='"') {
							if(inQuotes) {
								if(escaped) {
									sb.append(c);
									escaped = false;
								} else {
									inQuotes = false;
								}
							} else {
								inQuotes = true;
							}
 					} else if(inQuotes) {
 						sb.append(c);
 					} else {
 						switch(c) {
							case '/':
								isEndTag = true;
								break;
							case ' ':
								endField(tag,sb);
								tag = null;
								break;
							case '>':
								endField(tag,sb);
								go = false;
								break;
							case '=':
								tag = sb.toString();
								sb.setLength(0);
								break;
//							case ':':
//								ns = sb.toString();
//								sb.setLength(0);
//								break;
							case '?':
								if(!isXmlInfo)sb.append(c);
								break;
							default:
								sb.append(c);
 						}
 					}
				} while(go && (ch=r.read())>=0);
			} catch (IOException e) {
				throw new ParseException(e);
			}
			return this;
		}

		private void endField(String tag, StringBuilder sb) {
			if(name==null) {
				name = sb.toString();
				sb.setLength(0);
			} else {
				String value = sb.toString();
				sb.setLength(0);
				if(tag !=null && value != null) {
					if(props==null)props = new ArrayList<Prop>();
					props.add(new Prop(tag,value));
				}
			}
		}
		
		public String toString() {
			StringBuilder sb = new StringBuilder();
			sb.append(isEndTag?"End":"Start");
			sb.append(" Tag\n");
			sb.append("  Name: ");
			sb.append(name);
			if(props!=null) for(Prop p : props) {
				sb.append("\n     ");
				sb.append(p.tag);
				sb.append("=\"");
				sb.append(p.value);
				sb.append('"');
			}
			return sb.toString();
		}
	}
	
	private static class ArrayState {
		public boolean firstObj = true;
		public boolean didNext = false;
	}

	public static class State {
		public GreatExpectations greatExp;
		public DerTag unevaluated;
		public Stack<ArrayState> arrayInfo;
		private List<Prop> attribs;
		private int idx;
		public State(JaxInfo ji, DerTag dt) throws ParseException {
			greatExp = new RootExpectations(this, ji, null);
			unevaluated = null;
			attribs = null;;
		}
		
		public boolean hasAttributes() {
			return attribs!=null && idx<attribs.size();
		}

		public void push(Prop prop) {
			if(attribs==null) {
				attribs = new ArrayList<Prop>();
				idx = 0;
			}
			attribs.add(prop);
		}
		
		public Prop pop() {
			Prop rv = null;
			if(attribs!=null) {
				rv = attribs.get(idx++);
				if(idx>=attribs.size())attribs = null;
			}
			return rv;
		}
	}
	
	private static abstract class GreatExpectations {
		protected JaxInfo ji;
		protected GreatExpectations prev;
		private Map<String,String> ns;
		
		public GreatExpectations(State state, JaxInfo curr, GreatExpectations prev, DerTag derTag) throws ParseException {
			this.prev = prev;
			ns = null;
			ji = getDerived(state, curr,derTag);
		}
		
		public abstract boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException;

		// Recursively look back for any namespaces
		protected Map<String,String> getNS() {
			if(ns!=null)return ns;
			if(prev!=null) {
				return prev.getNS();
			}
			return null;
		}

		private void addNS(Prop prop) {
			Map<String,String> existingNS = getNS();
			if(ns==null)ns = new HashMap<String,String>();
			// First make a copy of previous NSs so that we have everything we need, but can overwrite, if necessary
			if(existingNS!=null && ns!=existingNS) {
				ns.putAll(ns);
			}
			ns.put(prop.tag, prop.value);
		}

		private JaxInfo getDerived(State state, JaxInfo ji, DerTag derTag) throws ParseException {
			if(derTag==null)return ji;
			
			List<Prop> props = derTag.props;
			
			Prop derived = null;
			if(props!=null) {
				// Load Namespaces (if any)
				for(Prop prop : props) {
					if(prop.tag.startsWith("xmlns:")) {
						addNS(prop);
					}
				}
				for(Prop prop : props) {
					if(prop.tag.endsWith(":type")) {
						int idx = prop.tag.indexOf(':');
						String potentialNS = "xmlns:"+prop.tag.substring(0,idx);
						Map<String,String> ns = getNS();
						boolean noNamespace = false;
						if(ns==null) {
							noNamespace = true;
						} else {
							String nsVal = ns.get(potentialNS);
							if(nsVal==null) noNamespace = true;
							else {
								derived = new Prop(Parsed.EXTENSION_TAG,prop.value);
								state.push(derived);
							}
						}
						if(noNamespace) {
							throw new ParseException(prop.tag + " utilizes an invalid Namespace prefix");
						}
					} else if(!prop.tag.startsWith("xmlns")) {
						state.push(prop);
					}
				}
			}
			return derived==null?ji:ji.getDerived(derived.value);
		}
	}
	
	private static class RootExpectations extends GreatExpectations {
		
		public RootExpectations(State state, JaxInfo curr, GreatExpectations prev) throws ParseException {
			super(state,curr,prev, null);
		}
		
		// @Override
		public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
			if(derTag.isXmlInfo) {
				parsed.event = START_DOC;
			} else if(ji.name.equals(derTag.name)) {
				if(derTag.isEndTag) {
					parsed.event = END_DOC;
					parsed.state.greatExp = prev;
				} else {
					//parsed.name = derTag.name;
					parsed.event = START_OBJ;
					parsed.state.greatExp = new ObjectExpectations(parsed.state,ji, this, false, derTag);	
				}
			}
			return false;
		}
	}
	
	private static class ObjectExpectations extends GreatExpectations {
		private boolean printName;

		public ObjectExpectations(State state, JaxInfo curr, GreatExpectations prev, boolean printName, DerTag derTag) throws ParseException {
			super(state, curr, prev, derTag);
			this.printName=printName;
		}

		// @Override
		public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
			if(derTag.isEndTag && ji.name.equals(derTag.name)) {
				parsed.state.greatExp = prev;
				parsed.event = END_OBJ;
				if(printName)parsed.name = ji.name;
			} else {
				//Standard Members
				for(JaxInfo memb : ji.members) {
					if(memb.name.equals(derTag.name)) {
						parsed.name = memb.name;
						if(memb.isArray) {
							parsed.state.unevaluated = derTag; // evaluate within Array Context
							parsed.event = START_ARRAY;
							parsed.state.greatExp = new ArrayExpectations(parsed.state,memb,this);
							return false;
						} else if(memb.isObject()) {
							if(derTag.isEndTag) {
								throw new ParseException("Unexpected End Tag </" + derTag.name + '>');
							} else {
								parsed.event = START_OBJ;

								parsed.state.greatExp = new ObjectExpectations(parsed.state, memb,this,true,derTag);
								return false;
							}
						} else { // a leaf
							if(derTag.isEndTag) {
								 throw new ParseException("Misplaced End Tag </" + parsed.name + '>');
							} else {
								parsed.state.greatExp = new LeafExpectations(parsed.state,memb, this);
								return true; // finish out Leaf without returning
							}
						}
					}
				}

				throw new ParseException("Unexpected Tag <" + derTag.name + '>');
			}
			return false;
		}
	}
	
	private static class LeafExpectations extends GreatExpectations {
		public LeafExpectations(State state, JaxInfo curr, GreatExpectations prev) throws ParseException {
			super(state, curr, prev, null);
		}

		// @Override
		public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
			if(ji.name.equals(derTag.name) && derTag.isEndTag) {
				parsed.event = NEXT;
				parsed.isString = ji.isString;
				parsed.state.greatExp = prev;
			} else {
				throw new ParseException("Expected </" + ji.name + '>');
			}
			return false;
		}		
	}

	private static class ArrayExpectations extends GreatExpectations {
		public ArrayExpectations(State state, JaxInfo ji, GreatExpectations prev) throws ParseException {
			super(state, ji, prev,null);
			if(state.arrayInfo==null)state.arrayInfo=new Stack<ArrayState>();
			state.arrayInfo.push(new ArrayState());
		}
		// @Override
		public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
			if(ji.name.equals(derTag.name) && !derTag.isEndTag) {
				if(ji.isObject()) {
					if(derTag.isEndTag) {
						throw new ParseException("Unexpected End Tag </" + derTag.name + '>');
					} else {
						ArrayState ai = parsed.state.arrayInfo.peek();  
						if(ai.firstObj || ai.didNext) {
							ai.firstObj = false;
							ai.didNext = false;
							parsed.event = START_OBJ;
							parsed.name=derTag.name;
							parsed.state.greatExp = new ObjectExpectations(parsed.state,ji,this,true, derTag);
						} else {
							ai.didNext = true;
							parsed.event = NEXT;
							parsed.state.unevaluated = derTag;
						}
					}
				} else { // a leave
					if(derTag.isEndTag) {
						 throw new ParseException("Misplaced End Tag </" + parsed.name + '>');
					} else {
						parsed.state.greatExp = new LeafExpectations(parsed.state, ji, this);
						return true; // finish out Leaf without returning
					}
				}
			} else { // Tag now different... Array is done
				parsed.state.unevaluated = derTag;
				parsed.event=END_ARRAY;
				parsed.state.greatExp = prev;
				parsed.state.arrayInfo.pop();
			}
			return false;
		}		
	}
	// @Override
	public Parsed<State> newParsed() throws ParseException {
		return new Parsed<State>(new State(jaxInfo, null));
	}

	// @Override
	public TimeTaken start(Env env) {
		return env.start("Rosetta XML In", Env.XML);
	}
	
}