/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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.
   */
  package org.apache.juneau.svl;
  
  import static org.apache.juneau.commons.lang.StateEnum.*;
  import static org.apache.juneau.commons.reflect.ReflectionUtils.*;
  import static org.apache.juneau.commons.utils.CollectionUtils.*;
  import static org.apache.juneau.commons.utils.StringUtils.*;
  import static org.apache.juneau.commons.utils.ThrowableUtils.*;
  import static org.apache.juneau.commons.utils.Utils.*;
  
  import java.io.*;
  import java.lang.reflect.*;
  import java.util.*;
  
  import org.apache.juneau.commons.collections.*;
  import org.apache.juneau.commons.lang.*;
  import org.apache.juneau.cp.*;
  
  /**
   * A var resolver session that combines a {@link VarResolver} with one or more session objects.
   *
   * <p>
   * Instances of this class are considered light-weight and fast to construct, use, and discard.
   *
   * <p>
   * This class contains the workhorse code for var resolution.
   *
   * <p>
   * Instances of this class are created through the {@link VarResolver#createSession()} and
   * {@link VarResolver#createSession(BeanStore)} methods.
   *
   * <h5 class='section'>Notes:</h5><ul>
   * 	<li class='warn'>This class is not guaranteed to be thread safe.
   * </ul>
   *
   * <h5 class='section'>See Also:</h5><ul>
   * 	<li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/SimpleVariableLanguageBasics">Simple Variable Language Basics</a>
   * </ul>
   */
  @SuppressWarnings("resource")
  public class VarResolverSession {
  
  	private static final AsciiSet AS1 = AsciiSet.of("\\{"), AS2 = AsciiSet.of("\\${}");
  
  	private static boolean containsVars(Collection<?> c) {
  		var f = Flag.create();
  		c.forEach(x -> {
  			if (x instanceof CharSequence && x.toString().contains("$"))
  				f.set();
  		});
  		return f.isSet();
  	}
  
  	private static boolean containsVars(Map<?,?> m) {
  		var f = Flag.create();
  		m.forEach((k, v) -> {
  			if (v instanceof CharSequence && v.toString().contains("$"))
  				f.set();
  		});
  		return f.isSet();
  	}
  
  	private static boolean containsVars(Object array) {
  		for (var i = 0; i < Array.getLength(array); i++) {
  			var o = Array.get(array, i);
  			if (o instanceof CharSequence && o.toString().contains("$"))
  				return true;
  		}
  		return false;
  	}
  
  	/*
  	 * Checks to see if string is of the simple form "$X{...}" with no embedded variables.
  	 * This is a common case, and we can avoid using StringWriters.
  	 */
  	private static boolean isSimpleVar(String s) {
  		// S1: Not in variable, looking for $
  		// S2: Found $, Looking for {
  		// S3: Found {, Looking for }
  		// S4: Found }
  
  		int length = s.length();
  		var state = S1;
  		for (var i = 0; i < length; i++) {
 			var c = s.charAt(i);
 			if (state == S1) {
 				if (c == '$') {
 					state = S2;
 				} else {
 					return false;
 				}
 			} else if (state == S2) {
 				if (c == '{') {
 					state = S3;
 				} else if (c < 'A' || c > 'z' || (c > 'Z' && c < 'a')) {   // False trigger "$X "
 					return false;
 				}
 			} else if (state == S3) {
 				if (c == '}')
 					state = S4;
 				else if (c == '{' || c == '$')
 					return false;
 			} else if (state == S4) {
 				return false;
 			}
 		}
 		return state == S4;
 	}
 
 	private final VarResolver context;
 
 	private final BeanStore beanStore;
 
 	/**
 	 * Constructor.
 	 *
 	 * @param context
 	 * 	The {@link VarResolver} context object that contains the {@link Var Vars} and context objects associated with
 	 * 	that resolver.
 	 * @param beanStore The bean store to use for resolving beans needed by vars.
 	 *
 	 */
 	public VarResolverSession(VarResolver context, BeanStore beanStore) {
 		this.context = context;
 		this.beanStore = BeanStore.of(beanStore);
 	}
 
 	/**
 	 * Adds a bean to this session.
 	 *
 	 * @param <T> The bean type.
 	 * @param c The bean type.
 	 * @param value The bean.
 	 * @return This object.
 	 */
 	public <T> VarResolverSession bean(Class<T> c, T value) {
 		beanStore.addBean(c, value);
 		return this;
 	}
 
 	/**
 	 * Returns the bean from the registered bean store.
 	 *
 	 * @param <T> The value type.
 	 * @param c The bean type.
 	 * @return
 	 * 	The bean.
 	 * 	<br>Never <jk>null</jk>.
 	 */
 	public <T> Optional<T> getBean(Class<T> c) {
 		Optional<T> t = beanStore.getBean(c);
 		if (! t.isPresent())
 			t = context.beanStore.getBean(c);
 		return t;
 	}
 
 	/**
 	 * Resolve all variables in the specified string.
 	 *
 	 * @param s
 	 * 	The string to resolve variables in.
 	 * @return
 	 * 	The new string with all variables resolved, or the same string if no variables were found.
 	 * 	<br>Returns <jk>null</jk> if the input was <jk>null</jk>.
 	 */
 	public String resolve(String s) {
 
 		if (s == null || s.isEmpty() || (s.indexOf('$') == -1 && s.indexOf('\\') == -1))
 			return s;
 
 		// Special case where value consists of a single variable with no embedded variables (e.g. "$X{...}").
 		// This is a common case, so we want an optimized solution that doesn't involve string builders.
 		if (isSimpleVar(s)) {
 			String var = s.substring(1, s.indexOf('{'));
 			String val = s.substring(s.indexOf('{') + 1, s.length() - 1);
 			Var v = getVar(var);
 			if (nn(v)) {
 				try {
 					if (v.streamed) {
 						var sw = new StringWriter();
 						v.resolveTo(this, sw, val);
 						return sw.toString();
 					}
 					s = v.doResolve(this, val);
 					if (s == null)
 						s = "";
 					return (v.allowRecurse() ? resolve(s) : s);
 				} catch (VarResolverException e) {
 					throw e;
 				} catch (Exception e) {
 					throw new VarResolverException(e, "Problem occurred resolving variable ''{0}'' in string ''{1}''", var, s);
 				}
 			}
 			return s;
 		}
 
 		try {
 			return resolveTo(s, new StringWriter()).toString();
 		} catch (IOException e) {
 			throw toRex(e); // Never happens.
 		}
 	}
 
 	/**
 	 * Resolves the specified strings in the string array.
 	 *
 	 * @param in The string array containing variables to resolve.
 	 * @return An array with resolved strings.
 	 */
 	public String[] resolve(String[] in) {
 		var out = new String[in.length];
 		for (var i = 0; i < in.length; i++)
 			out[i] = resolve(in[i]);
 		return out;
 	}
 
 	/**
 	 * Convenience method for resolving variables in arbitrary objects.
 	 *
 	 * <p>
 	 * Supports resolving variables in the following object types:
 	 * <ul>
 	 * 	<li>{@link CharSequence}
 	 * 	<li>Arrays containing values of type {@link CharSequence}.
 	 * 	<li>Collections containing values of type {@link CharSequence}.
 	 * 		<br>Collection class must have a no-arg constructor.
 	 * 	<li>Maps containing values of type {@link CharSequence}.
 	 * 		<br>Map class must have a no-arg constructor.
 	 * </ul>
 	 *
 	 * @param <T> The value type.
 	 * @param o The object.
 	 * @return The same object if no resolution was needed, otherwise a new object or data structure if resolution was
 	 * needed.
 	 */
 	@SuppressWarnings({ "rawtypes", "unchecked" })
 	public <T> T resolve(T o) {
 		if (o == null)
 			return null;
 		if (o instanceof CharSequence o2)
 			return (T)resolve(o2.toString());
 		if (isArray(o)) {
 			if (! containsVars(o))
 				return o;
 			var o2 = Array.newInstance(o.getClass().getComponentType(), Array.getLength(o));
 			for (var i = 0; i < Array.getLength(o); i++)
 				Array.set(o2, i, resolve(Array.get(o, i)));
 			return (T)o2;
 		}
 		if (o instanceof Set o2) {
 			try {
 				if (! containsVars(o2))
 					return o;
 				Set o3 = info(o).getDeclaredConstructor(x -> x.isPublic() && x.getParameterCount() == 0).map(ci -> safe(() -> (Set)ci.inner().newInstance())).orElseGet(LinkedHashSet::new);
 				Set o4 = o3;
 				o2.forEach(x -> o4.add(resolve(x)));
 				return (T)o3;
 			} catch (VarResolverException e) {
 				throw e;
 			} catch (Exception e) {
 				throw new VarResolverException(e, "Problem occurred resolving set.");
 			}
 		}
 		if (o instanceof List o2) {
 			try {
 				if (! containsVars(o2))
 					return o;
 				List o3 = info(o).getDeclaredConstructor(x -> x.isPublic() && x.getParameterCount() == 0).map(ci -> safe(() -> (List)ci.inner().newInstance())).orElseGet(() -> list());
 				List o4 = o3;
 				o2.forEach(x -> o4.add(resolve(x)));
 				return (T)o3;
 			} catch (VarResolverException e) {
 				throw e;
 			} catch (Exception e) {
 				throw new VarResolverException(e, "Problem occurred resolving collection.");
 			}
 		}
 		if (o instanceof Map o2) {
 			try {
 				if (! containsVars(o2))
 					return o;
 				Map o3 = info(o).getDeclaredConstructor(x -> x.isPublic() && x.getParameterCount() == 0).map(ci -> safe(() -> (Map)ci.inner().newInstance())).orElseGet(LinkedHashMap::new);
 				Map o4 = o3;
 				o2.forEach((k, v) -> o4.put(k, resolve(v)));
 				return (T)o3;
 			} catch (VarResolverException e) {
 				throw e;
 			} catch (Exception e) {
 				throw new VarResolverException(e, "Problem occurred resolving map.");
 			}
 		}
 		return o;
 	}
 
 	/**
 	 * Resolves variables in the specified string and sends the output to the specified writer.
 	 *
 	 * <p>
 	 * More efficient than first parsing to a string and then serializing to the writer since this method doesn't need
 	 * to construct a large string.
 	 *
 	 * @param s The string to resolve variables in.
 	 * @param out The writer to write to.
 	 * @return The same writer.
 	 * @throws IOException Thrown by underlying stream.
 	 */
 	public Writer resolveTo(String s, Writer out) throws IOException {
 
 		// S1: Not in variable, looking for $
 		// S2: Found $, Looking for {
 		// S3: Found {, Looking for }
 
 		var state = S1;
 		var isInEscape = false;
 		var hasInternalVar = false;
 		var hasInnerEscapes = false;
 		var varType = (String)null;
 		var varVal = (String)null;
 		var x = 0;
 		var x2 = 0;
 		var depth = 0;
 		var length = s.length();
 		for (var i = 0; i < length; i++) {
 			var c = s.charAt(i);
 			if (state == S1) {
 				if (isInEscape) {
 					if (c == '\\' || c == '$') {
 						out.append(c);
 					} else {
 						out.append('\\').append(c);
 					}
 					isInEscape = false;
 				} else if (c == '\\') {
 					isInEscape = true;
 				} else if (c == '$') {
 					x = i;
 					x2 = i;
 					state = S2;
 				} else {
 					out.append(c);
 				}
 			} else if (state == S2) {
 				if (isInEscape) {
 					isInEscape = false;
 				} else if (c == '\\') {
 					hasInnerEscapes = true;
 					isInEscape = true;
 				} else if (c == '{') {
 					varType = s.substring(x + 1, i);
 					x = i;
 					state = S3;
 				} else if (c < 'A' || c > 'z' || (c > 'Z' && c < 'a')) {  // False trigger "$X "
 					if (hasInnerEscapes)
 						out.append(unescapeChars(s.substring(x, i + 1), AS1));
 					else
 						out.append(s, x, i + 1);
 					x = i + 1;
 					state = S1;
 					hasInnerEscapes = false;
 				}
 			} else if (state == S3) {
 				if (isInEscape) {
 					isInEscape = false;
 				} else if (c == '\\') {
 					isInEscape = true;
 					hasInnerEscapes = true;
 				} else if (c == '{') {
 					depth++;
 					hasInternalVar = true;
 				} else if (c == '}') {
 					if (depth > 0) {
 						depth--;
 					} else {
 						varVal = s.substring(x + 1, i);
 						Var r = getVar(varType);
 						if (r == null) {
 							if (hasInnerEscapes)
 								out.append(unescapeChars(s.substring(x2, i + 1), AS2));
 							else
 								out.append(s, x2, i + 1);
 							x = i + 1;
 						} else {
 							varVal = (hasInternalVar && r.allowNested() ? resolve(varVal) : varVal);
 							try {
 								if (r.streamed)
 									r.resolveTo(this, out, varVal);
 								else {
 									String replacement = r.doResolve(this, varVal);
 									if (replacement == null)
 										replacement = "";
 									// If the replacement also contains variables, replace them now.
 									if (replacement.indexOf('$') != -1 && r.allowRecurse())
 										replacement = resolve(replacement);
 									out.append(replacement);
 								}
 							} catch (VarResolverException e) {
 								throw e;
 							} catch (Exception e) {
 								throw new VarResolverException(e, "Problem occurred resolving variable ''{0}'' in string ''{1}''", varType, s);
 							}
 							x = i + 1;
 						}
 						state = S1;
 						hasInnerEscapes = false;
 					}
 				}
 			}
 		}
 		if (isInEscape)
 			out.append('\\');
 		else if (state == S2)
 			out.append('$').append(unescapeChars(s.substring(x + 1), AS1));
 		else if (state == S3)
 			out.append('$').append(varType).append('{').append(unescapeChars(s.substring(x + 1), AS2));
 		return out;
 	}
 
 	protected FluentMap<String,Object> properties() {
 		// @formatter:off
 		return filteredBeanPropertyMap()
 			.a("context.beanStore", this.context.beanStore)
 			.a("var", this.context.getVarMap().keySet())
 			.a("session.beanStore", beanStore);
 		// @formatter:on
 	}
 
 	@Override /* Overridden from Object */
 	public String toString() {
 		return r(properties());
 	}
 
 	/**
 	 * Returns the {@link Var} with the specified name.
 	 *
 	 * @param name The var name (e.g. <js>"S"</js>).
 	 * @return The {@link Var} instance, or <jk>null</jk> if no <c>Var</c> is associated with the specified name.
 	 */
 	protected Var getVar(String name) {
 		Var v = this.context.getVarMap().get(name);
 		return nn(v) && v.canResolve(this) ? v : null;
 	}
 }