package eu.simuline.m2latex.core;
   
   //import org.apache.maven.project.io.xpp3.MavenXpp3Reader;
   //import org.apache.maven.project.Model;
   
   import eu.simuline.m2latex.core.CommandExecutor.CmdResult;
   
   import java.io.InputStream;
   import java.io.IOException;
  
  import java.util.Properties;
  import java.util.SortedSet;
  import java.util.TreeSet;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import java.util.jar.Attributes;
  import java.util.jar.Manifest;
  
  // TBD: extract this class into a separate git repository
  // and use it as a submodule.
  /**
   * Gives access to meta info on this piece of software stored in the jar-file
   * which provides this class.
   * Start with version information.
   */
  public class MetaInfo {
  
  
    /**
     * Name of the folder <code>META-INF</code> in the jar file which provides this 
     * class. 
     * This contains 
     * <ul>
     * <li>the folder <code>maven</code> created by maven and containing information 
     * like pom properties and pom itself which we currently do not consider</li>
     * <li>the manifest file named {@link MetaInfo.ManifestInfo#MANIFEST_FILE}.</li>
     * </ul>
     */
    private final static String META_FOLDER = "META-INF/";
  
    /**
     * Creates the stream for the file given by <code>fileName</code>. 
     * 
     * @param fileName
     *    a filename
     * @return
     *    a non-null input stream to read from <code>fileName</code>. 
     * @throws BuildFailureException
     *    TMI01: if the stream to <code>fileName</code> could not be created.
     */
    static InputStream getStream(String fileName) throws BuildFailureException {
      InputStream res = MetaInfo.class.getClassLoader().getResourceAsStream(fileName);
      if (res == null) {
        throw new BuildFailureException(
            "TMI01: Cannot get stream to file '" + fileName + "'. ");
      }
      return res;
    }
  
    /**
     * Returs properties read from the given file named <code>fileName</code>. 
     * 
     * @param fileName
     *    an input stream to read from <code>fileName</code>. 
     * @return
     *    Properties read from <code>fileName</code>. 
     * @throws BuildFailureException
     *    <ul>
     *    <li>TMI01: if the stream to <code>fileName</code> could not be created. </li>
     *    <li>TMI02: if the properties could not be read from <code>fileName</code>. </li>
     *    </ul>
     */
    static Properties getProperties(String fileName)
        throws BuildFailureException {
      try {
        Properties properties = new Properties();
        // may throw TMI01, also TFU01?
        properties.load(MetaInfo.getStream(fileName));
        return properties;
      } catch (IOException e) {
        // TBD: assign exception identifier
        throw new BuildFailureException(
            "TMI02: Cannot load properties from file '" + fileName + "'. ");
      }
    }
    
      
  
  	/**
  	 * Reflects the pieces of information given by the manifest file 
  	 * with manifest version {@link #MANIFEST_VERSION} augmented 
  	 * by {@link #getCreatedBy()} and by {@link #getBuildJdkSpec()} 
  	 * which are both due to to the maven jar plugin and specific version 
  	 * given by {@link #MVN_JAR_PLUGIN}. 
  	 *  
  	 * TBD: change user and see whether author changes then also 
 	 * @author ernst
 	 */
 	static class ManifestInfo {
 
 		/**
 		 * The manifest version this class is designed for. 
 		 * When creating an instance, that version is checked 
 		 * and if the version found differs from that one, an exception is thrown. 
 		 */
 		private final static String MANIFEST_VERSION = "1.0";
 
 		/**
 		 * An indicator that the jar file 
 		 * containing the manifest represented by this object 
 		 * was created by maven jar plugin with proper version. 
 		 */
     // TBD: decide how to make independent of the version 
 		private final static String MVN_JAR_PLUGIN = "Maven JAR Plugin 3.4.2";
 
 		/**
 		 * The name of the manifest file which is in the folder {@link #META_FOLDER} 
 		 * of the jar file which provides this class. 
 		 */
 		private final static String MANIFEST_FILE = "MANIFEST.MF";
 
 		/**
 		 * These attributes are added by the maven jar plugin in version 3.2.0 and is specific for that. 
 		 * Thus the according value is exactly the specification of that plugin with version info. 
 		 */
 		private final static Attributes.Name CREATED_BY =
 				new Attributes.Name("Created-By");
 
 		/**
 		 * The version of the jdk used to build the jar containing the manifest 
 		 * represented by this object. 
 		 * These attributes are added by the maven jar plugin version 3.2.0 and is specific for that. 
 		 */
 		private final static Attributes.Name BUILD_JDK_SPEC =
 				new Attributes.Name("Build-Jdk-Spec");
 
 		// TBD: decide whether this is sensible 
 		private final Manifest manifest;
 
 		/**
 		 * The main attributes of the manifest. 
 		 */
 		private final Attributes mAtts;
 
 		/**
 		 * Creates Manifest info instance. 
      * 
 		 * @throws BuildFailureException
 		 *    TMI01: if the stream to the manifest file is not readable 
 		 *    TMI03: the manifest file is not readable although the stream is ok. 
 		 */
 		ManifestInfo() throws BuildFailureException {
 
 			//System.out.println("MANIFEST: ");
 			try {
 				// getStream may throw TMI01
 				this.manifest = new Manifest(getStream(META_FOLDER + MANIFEST_FILE));
 			} catch (IOException e) {
 				throw new BuildFailureException(
 						"TMI03: IOException reading manifest. ");
 			}
 			this.mAtts = this.manifest.getMainAttributes();
 			// check the manifest version 
 			if (!MANIFEST_VERSION.equals(getManifestVersion())) {
 				throw new IllegalStateException(
 						"Found manifest with version '" + getManifestVersion()
 								+ " where expected version " + MANIFEST_VERSION + ". ");
 			}
 			// CAUTION: don't use getCreatedBy() as this throws an exception 
 			// if this jar is not created with the correct maven plugin 
 			// (or even without maven at all)
 			if (!MVN_JAR_PLUGIN.equals(this.mAtts.get(CREATED_BY))) {
 				// MVN_JAR_PLUGIN includes the version also 
 				throw new IllegalStateException(
 						"Found manifest not created by '" + MVN_JAR_PLUGIN + "' message was '"+this.mAtts.get(CREATED_BY) +"'. ");
 			}
 
 			//		Map<String, Attributes> entriesMf = mf.getEntries();
 
 
 			// seems to correspond with Attributes.Name
 			// MANIFEST_VERSION,
 			// IMPLEMENTATION_TITLE, IMPLEMENTATION_VERSION, IMPLEMENTATION_VENDOR,
 			// SPECIFICATION_TITLE, SPECIFICATION_VERSION, SPECIFICATION_VENDOR,
 			//
 			// defined but not occurring:
 			// SIGNATURE_VERSION, CONTENT_TYPE, CLASS_PATH, MAIN_CLASS, SEALED,
 			// EXTENSION_LIST, EXTENSION_NAME, EXTENSION_INSTALLATION,
 			// IMPLEMENTATION_VENDOR_ID
 			// IMPLEMENTATION_URL,
 			//
 			// occurring but not defined in Attributes.Name:
 			// Created-By: Maven Jar Plugin 3.2.0, Build-Jdk-Spec: 11
 
 			//this.implVersion = this.mAtts.get(Attributes.Name.IMPLEMENTATION_VERSION).toString();
 
 			// TBC: seems to be empty in this case.
 			// in maven-jar-plugin set by manifestSections
 			// System.out.println("Manifest entries"+entriesMf);
 
 			// Enumeration entriesJar = mf.entries();
 			// System.out.println("jar entries"+entriesJar);
 		}
 
 		private String getAttrValue(Object name) {
 			// is in fact a string always but this is to detect null pointer exceptions 
 			return this.mAtts.get(name).toString();
 		}
 
 		/**
 		 * Returns the version of the implementation. 
 		 * This is the version given by the maven coordinates.
 		 * 
 		 *  @return
 		 */
 		protected String getImplVersion() {
 			return getAttrValue(Attributes.Name.IMPLEMENTATION_VERSION);
 		}
 
 		/**
 		 * Returns the vendor of the implementation. 
 		 * This is the vendor given by the maven <code>project.organization.name</code>.
 		 * 
 		 *  @return
 		 */
 		protected String getImplVendor() {
 			return getAttrValue(Attributes.Name.IMPLEMENTATION_VENDOR);
 		}
 
 		protected String getManifestVersion() {
 			return getAttrValue(Attributes.Name.MANIFEST_VERSION);
 		}
 
 		protected String getSpecVersion() {
 			return getAttrValue(Attributes.Name.SPECIFICATION_VERSION);
 		}
 
 		// specific for Maven Jar Plugin 3.2.0 which is also the string returned. 
 		protected String getCreatedBy() {
 			return getAttrValue(CREATED_BY);
 		}
 
 		// specific for Maven Jar Plugin 3.2.0 
 		protected String getBuildJdkSpec() {
 			return getAttrValue(BUILD_JDK_SPEC);
 		}
 
 
 		protected String getPackageImplVersion() {
 			return this.getClass().getPackage().getImplementationVersion();
 		}
 
 		// TBD: tie names to values. 
 		@Override
 		public String toString() {
 			StringBuilder stb = new StringBuilder();
 			for (String line : toStringArr()) {
 				stb.append(line);
 				stb.append('\n');
 			}
 			return stb.toString();
 		}
 
 		public String[] toStringArr() {
 			//	    List<String> lines = new ArrayList<String>();
 			//	    Object key, value;
 			//	    for (Map.Entry<Object,Object> entry : mAtts.entrySet()) {
 			//		key   = entry.getKey();
 			//		value = entry.getValue();
 			//		lines.add("   '" + key   + "' cls: " + key.getClass() +
 			//			"'->'" + value + "' cls: " + value.getClass());
 			//	    }
 			//	    return lines.toArray(new String[lines.size()]);
 
 			return new String[] {"MANIFEST: (" + getManifestVersion() + ")",
 					"       Implementation-Version: '" + getImplVersion() + "'",
 					"PackageImplementation-Version: '" + getPackageImplVersion() + "'"
 					//"creator: '" + getCreatedBy() + "'",
 					//"version jdk: '" + getBuildJdkSpec() + "'"
 			};
 		}
 
 	} // class ManifestInfo
 
 
 	/**
 	 * Reflects the pieces of information 
 	 * given by the <code>git-commit-id-plugin</code> in the current(?) version. 
 	 * 
 	 * 
 	 * @author ernst
 	 */
 	class GitProperties {
 		private final static String GIT_PROPS_FILE = "git.properties";
 
 		private final static String GIT_BUILD_VERSION = "git.build.version";
 		private final static String GIT_COMMIT_ID_DESCRIBE =
 				"git.commit.id.describe";
 		private final static String GIT_CLOSEST_TAG_NAME = "git.closest.tag.name";
 		private final static String GIT_CLOSEST_TAG_COMMIT_COUNT =
 				"git.closest.tag.commit.count";
 		private final static String GIT_COMMIT_ID_ABBREV = "git.commit.id.abbrev";
 		private final static String GIT_DIRTY = "git.dirty";
 		private final static String GIT_BUILD_TIME = "git.build.time";
 
 
 		private final Properties properties;
 
 		/**
 		 * @throws BuildFailureException
 		 *    <ul>
 		 *    <li>TMI01: if the stream to {@link #GIT_PROPS_FILE} could not be created. </li>
 		 *    <li>TMI02: if the properties could not be read from @link #GIT_PROPS_FILE}. </li>
 		 *    </ul>
 		 */
 		GitProperties() throws BuildFailureException {
 			// TBD: extract properties 
 			this.properties = getProperties(GIT_PROPS_FILE);
 
 			//String gitBuildVersion = getBuildVersion();
 			// latex-maven-plugin-1.4-44-g555bde8-dirty
 			// is constructed from 
 			//String gitCommitIdDescribe = getCommitIdDescribe();
 			// also interesting: 
 		}
 
 		private String getAttrValue(String key) {
 			// is in fact a string always but this is to detect null pointer exceptions 
 			return this.properties.get(key).toString();
 		}
 
 		/**
 		 * Returns the build version which is the same as the version in the coordinate 
 		 * provided the <code>maven-release-plugin</code> is used correctly. 
 		 * @return
 		 *    the build version. 
 		 */
 		String getBuildVersion() {
 			return getAttrValue(GIT_BUILD_VERSION);
 		}
 
 		// latex-maven-plugin-1.4-44-g555bde8-dirty
 		/**
 		 * Returns the commit identifiers description TBC which consists of 
 		 * <ul>
 		 * <li> the closest tag name as given by {@link #getClosestTagName()} </li>
 		 * <li> the number of commits since the last tag 
 		 *      given by {@link #getClosestTagCommitCount()}</li>
 		 * <li> something unknown which leads to the 'g'</li>
 		 * <li> git.commit.id.abbrev=555bde8</li>
 		 * <li> 'dirty' if {@link #getDirty()} returns true. </li>
 		 * </ul>
 		 * each segment separated by a dash
 		 * 
 		 * @return
 		 *    the commit identifiers description
 		 */
 		String getCommitIdDescribe() {
 			return getAttrValue(GIT_COMMIT_ID_DESCRIBE);
 		}
 
 		// latex-maven-plugin-1.4
 		/**
 		 * This is the artifact id and, separated by a dash, 
 		 * by the current version tag, if there is one, 
 		 * else, i.e. for snapshots, by the next lowest. 
 		 * The tag given is current, iff {@link #getClosestTagCommitCount()} returns 0.  
 		 *
 		 * @return
 		 *    the closest tag name for the last commit. 
 		 */
 		String getClosestTagName() {
 			return getAttrValue(GIT_CLOSEST_TAG_NAME);
 		}
 
 		// TBD: shall be a number, not a string 
 		/**
 		 * Returns the number of commits since the last tag 
 		 * which is given by {@link #getClosestTagName()}. 
 		 * 
 		 * @return
 		 *    the number of commits since the last tag. 
 		 */
 		String getClosestTagCommitCount() {
 			return getAttrValue(GIT_CLOSEST_TAG_COMMIT_COUNT);
 		}
 
 		// TBC: maybe a string maybe an int or what. 
 		/**
 		 * Returns the abbreviated hash of the last commit.
 		 * 
 		 * @return
 		 *    the abbreviated hash of the last commit.
 		 */
 		String getCommitIdAbbrev() {
 			return getAttrValue(GIT_COMMIT_ID_ABBREV);
 		}
 
 		// TBD: this shall not be a string but a boolean 
 		/**
 		 * Returns whether the current working environment is dirty, 
 		 * i.e. there is something not committed inside. 
 		 * 
 		 * @return
 		 *    whether the current working environment is dirty.
 		 */
 		String getDirty() {
 			return getAttrValue(GIT_DIRTY);
 		}
 
 		/**
 		 * Returns the build time TBD: not just a string 
 		 * @return
 		 * the build time as a string. 
 		 */
 		String getBuildTime() {
 			return getAttrValue(GIT_BUILD_TIME);
 		}
 
 		@Override
 		public String toString() {
 			StringBuilder stb = new StringBuilder();
 			stb.append("build version:  '" + getBuildVersion() + "'\n");
 			stb.append("commit id desc: '" + getCommitIdDescribe() + "'\n");
 			stb.append("buildTime:      '" + getBuildTime() + "'\n");
 			return stb.toString();
 		}
 
 		void log() {
 			MetaInfo.this.log.info("build version:  '" + getBuildVersion() + "'");
 			MetaInfo.this.log.info("commit id desc: '" + getCommitIdDescribe() + "'");
 			MetaInfo.this.log.info("buildTime:      '" + getBuildTime() + "'");
 		}
 
 	} // class GitProperties
 
  	static class Version implements Comparable<Version> {
 
 		private final static String VERSION_UNKNOWN = "<unknown>";
 
 		private final String text;
 
 		private final Matcher matcher;
 
 		/**
 		 * The version as a string of the form as given by the converter
 		 */
 		private final String versionStr;
 
     /**
      * The segments of the version string. 
      * Typically these are separated by a dot, 
      * but other separators or the lack of a separator may happen also. 
      */
 		private final List<Number> segments;
 
 		/**
 		 * Create a version for a converter <code>conv</code> 
 		 * invoking it with the proper option using <code>executor</code>. 
 		 * This is used in {@link MetaInfo#printMetaInfo(boolean, SortedSet<Converter>)} 
 		 * to create the version info of a converter. 
 		 * 
 		 * @param conv
 		 *    a converter.
 		 * @param executor
 		 *    an executor to execute the command of the converter 
 		 *    to obtain a feedback containing the version. 
 		 * @throws BuildFailureException
 		 *    TEX01 if invocation of <code>command</code> fails very basically.
 		 */
 		Version(Converter conv, CommandExecutor executor)
 				throws BuildFailureException {
 			this(conv.getVersionEnvironment(), conv.getVersionPattern(),
 					// may throw BuildFailureException
 					conv.getVersionInfo(executor));
 		}
 
 		/**
 		 * Create a version from given pattern. 
 		 * This is used in {@link Version(Converter, CommandExecutor)} 
 		 * to create the version info of a converter 
 		 * but also in {@link VersionInterval#VersionInterval(Converter, String)} 
 		 * to get the minimum/maximum expected version of a converter. 
 		 * 
 		 * @param patternEnv
 		 *    The pattern <code>patternEnv</code> is a format string 
 		 *    containing the literal <code>%s</code>. 
 		 *    This literal indicates the location of the version pattern <code>patternVrs</code>. 
 		 *    The string <code>text</code> shall match <code>patternEnv</code> 
 		 *    with <code>%s</code> substituted by <code>patternVrs</code>. 
 		 * @param patternVrs
 		 *    the regex pattern expected for this version. 
 		 *    This is in a form 
 		 *    as returned by {@link Converter#getVersionPattern()}.
 		 * @param text
 		 *    some text containing (among other things)
 		 *    version information described by <code>patternVrs</code> 
 		 *    and conforming to <code>patternEnv</code>. 
 		 *    The origin of that text may be output of invocation of a converter 
 		 *    or a property file with allowed versions (as version intervals). 
 		 */
 		Version(String patternEnv, String patternVrs, String text) {
 			this.text = text;
  			this.matcher =
 					Pattern.compile(String.format(patternEnv, patternVrs)).matcher(text);
 			if (!this.matcher.find()) {
 				this.versionStr = VERSION_UNKNOWN;
 				this.segments = null;// TBD: eliminate 
 				return;
 			}
 			this.versionStr = this.matcher.group(1);
 			this.segments = new ArrayList<Number>(this.matcher.groupCount()-1);
 			String segment;
 			Number num;
       // group 1 is the enclosing group. Thus we start with the second one 
 			for (int idx = 2; idx <= this.matcher.groupCount(); idx++) {
 				segment = this.matcher.group(idx);
 				if (segment == null) {
 					break;
 				}
 				num = segStr2Num(segment);
 				this.segments.add(num);
 			}
 		}
 
     /**
      * Returns a number representing the segment of a version string. 
      * This is a Byte if the segment is a lower case letter, 
      * an Integer if it is an integer and a Double if it has the form number.number
      * @param segment
      * @return
      */
 		private static Number segStr2Num(String segment) {
 			if (segment.isEmpty()) {
 				// TBD: very weak. 
 				// This is allowed only at last place with pattern [a-z]
 				return Byte.MAX_VALUE;
 			}
 			if (Pattern.matches("[a-z]", segment)) {
 				return Byte.valueOf((byte) segment.codePointAt(0));
 			}
 			// TBC: why works the 2nd version, but the 1st does not?
 			// num = segment.indexOf('.') == -1
 			// ? Integer.valueOf(segment)
 			// : Double .valueOf(segment);
 			if (segment.indexOf('.') == -1) {
 				return Integer.valueOf(segment);
 			} else {
 				return Double.valueOf(segment);
 			}
 		}
 
 		boolean isMatching() {
 			return this.segments != null;
 		}
 
 		String getText() {
 			return this.text;
 		}
 
 		String getString() {
 			return this.versionStr;
 		}
 
 		private List<Number> getSegments() {
 			return this.segments;
 		}
 
 		public int compareTo(Version other) {
 			int idxMin = Math.min(getSegments().size(), other.getSegments().size());
 			int sign;
 			for (int idx = 0; idx < idxMin; idx++) {
 				// TBD: eliminate hack 
 				sign = (int) Math.signum(getSegments().get(idx).doubleValue()
 						-              other.getSegments().get(idx).doubleValue());
 				switch (sign) {
 					case 0:
 						continue;
 					case -1:
 						// fall through 
 					case +1:
 						return sign;
 					default:
 						throw new IllegalStateException("Found unexpected signum. ");
 				}
 			}
 			// TBD: unoconv is an example where 0.9 and 0.9.0 occur, 
 			// in different distributions but both versions identical 
 			// This must be taken into account 
       // For fig2dev with verions 3.2.7x and 3.2.8, this seems ok. 
 			return getSegments().size() - other.getSegments().size();
 		}
 
 	} // class Version 
 
 	/**
 	 * An interval of versions, representing intervals 
 	 * between the boundaries {@link #min} and {@link #min} 
 	 * which offers a containment predicate {@link #contains(Version)}. 
 	 * <p>
 	 * Tied to this is a string representation given by {@link #toString()} 
 	 * and also used by the constructor {@link #VersionInterval(Converter, String)}.
 	 */
 	static class VersionInterval {
 
 		/**
 		 * Separator between minimum version and maximum version in string representation. 
 		 * This must be a character not occurring within a version string. 
 		 * We have a piece of software, see {@link Converter#Latex2rtf} 
 		 * which has a blank in the version string and as a consequence, 
 		 * we cannot use a blank here.  
 		 */
 		private final static char SEP = ';';
 
 		/**
 		 * The pattern for a one point interval, essentially the version within brackets. 
 		 * Note that the version string is represented as the formatter <code>%s</code>.
 		 * 
 		 * @see #ENV_PATTERN2LOW
 		 * @see #ENV_PATTERN2HIG
 		 */
 		private final static String ENV_PATTERN1 = "^\\[%s\\]$";
 
 		/**
 		 * The pattern for a non-degenerate interval, 
 		 * minimum and maximum version separated by {@link #SEP} 
 		 * and enclosed within brackets. 
 		 * The minimum version string is represented as the formatter <code>%s</code> 
 		 * whereas the maximum version string is represented by the general pattern. 
 		 * 
 		 * @see #ENV_PATTERN1
 		 * @see #ENV_PATTERN2HIG
 		 */
 		private final static String ENV_PATTERN2LOW = "^\\[%s" + SEP + ".*\\]$";
 
 		/**
 		 * The pattern for a non-degenerate interval, 
 		 * minimum and maximum version separated by {@link #SEP} 
 		 * and enclosed within brackets. 
 		 * The maximum version string is represented as the formatter <code>%s</code> 
 		 * whereas the minimum version string is represented by the general pattern. 
 		 * 
 		 * @see #ENV_PATTERN1
 		 * @see #ENV_PATTERN2LOW
 		 */
 		private final static String ENV_PATTERN2HIG = "^\\[.*" + SEP + "%s\\]$";
 
 		/**
 		 * The minimum version (inclusive) contained in this interval. 
 		 */
 		private final Version min;
 
 		/**
 		 * The maximum version (inclusive) contained in this interval. 
 		 */
 		private final Version max;
 
 		/**
 		 * Creates a version interval from the converter and from the text string 
 		 * read from the version properties file. 
 		 * 
 		 * @param conv
 		 *    the converter for which to create the version interval. 
 		 *    This is used mostly to determine {@link Converter#getVersionPattern()}.
 		 * @param text
 		 *    the text representation for the interval to be created 
 		 *    which is as described for {@link #toString()}. 
 		 *    This may well be <code>null</code>.
 		 * @throws IllegalStateException
 		 *    if either <code>text</code> is <code>null</code>
 		 *    which means that there is no version for <code>conv</code>
 		 *    or if this created version interval
 		 *    does not have the representation given by <code>text</code>.
 		 */
 		VersionInterval(Converter conv, String text) {
 			String patternVrs = conv.getVersionPattern();
 			if (text == null) {
 				throw new IllegalStateException(
 						"Found no expected version for converter " + conv + ". ");
 			}
 			if (text.indexOf(SEP) == -1) {
 				// Here, we have an interval [element]
 				this.min = new Version(ENV_PATTERN1, patternVrs, text);
 				this.max = this.min;
 				if (!this.min.isMatching()) {
 					throw new IllegalStateException(String.format(
 							"Expected version interval '%s' "
 									+ "does not match expression '^\\[%s\\]$'. ",
 							text, patternVrs));
 				}
 			} else {
 				// Here, we have an interval [min;max]
 				this.min = new Version(ENV_PATTERN2LOW, patternVrs, text);
 				this.max = new Version(ENV_PATTERN2HIG, patternVrs, text);
 				if (!(this.min.isMatching() && this.max.isMatching())) {
 					throw new IllegalStateException(String.format(
 							"Expected version interval '%s' "
 									+ "does not match expression '^\\[%s%c%s\\]$'. ",
 							text, patternVrs, SEP, patternVrs));
 				}
 			}
 			String expVersionItvStr = toString();
 			if (!text.equals(expVersionItvStr)) {
 				throw new IllegalStateException(
 						String.format("Expected version '%s' reconstructed as '%s'. ", text,
 								expVersionItvStr));
 			}
 		}
 
 		/**
 		 * Returns whether <code>version</code> is contained in this interval. 
 		 * 
 		 * @param version
 		 *    some version. 
 		 * @return
 		 *    whether <code>version</code> is contained in this interval. 
 		 */
 		boolean contains(Version version) {
 			return this.min.compareTo(version) <= 0
 					&& this.max.compareTo(version) >= 0;
 		}
 
 		/**
 		 * Returns a representation inspired by math and used in version property file. 
 		 * It is just the format 
 		 * which is read by the constructor {@link #VersionInterval(Converter, String)}.
 		 * 
 		 * @return
 		 *    string representation of the form <code>[min;max]</code> 
 		 *    except if <code>min</code> and <code>max</code> coincide, 
 		 *    then it is just <code>[min]</code>.
 		 */
 		@Override
 		public String toString() {
 			StringBuilder res = new StringBuilder();
 			res.append('[');
 			res.append(this.min.getString());
 
 			if (this.min != this.max) {
 				res.append(SEP);
 				res.append(this.max.getString());
 			}
 			res.append(']');
 			return res.toString();
 		}
 	} // class VersionInterval
 
   /**
    * Represents the maven coordinates of this maven plugin. 
    */
   static class Coordinates {
     final String groupId;
     final String artifactId;
     final String version;
 
     Coordinates(String groupId, String artifactId, String version) {
       this.groupId = groupId;
       this.artifactId = artifactId;
       this.version = version;
     }
   } // class Coordinates 
 
 	/**
 	 * The name of the file containing the version properties.
 	 * For each {@link Converter}, the range of possible versions is given
 	 * in a separate line of the form <code>command=[a;b]</code>
 	 * or <code>command=[a]</code> for a=b. 
 	 * Also comments starting with {@literal #} are allowed.
 	 */
 	private final static String VERSION_PROPS_FILE = "version.properties";
 
 	/**
 	 * Format string used in {@link #printMetaInfo(boolean, SortedSet<Converter>)} 
 	 * to define a table of converters and their versions
 	 * with rows (warning), converter, version quote, 
 	 * actual version and allowed version interval.  
 	 */
 	private final static String TOOL_VERSION_FORMAT = "%s%-18s %s '%s'%s%s";
 
 
 
 	/**
 	 * The command <code>which</code> as a string. 
 	 */
 	private static final String CMD_WHICH = "which";
 
   private static final String COORDINATE_PROPERTY_FILE_NAME = 
   META_FOLDER + "maven/" + "eu.simuline.m2latex/"
 					+ "latex-maven-plugin/" + "pom.properties";
 
 	/**
 	 * Executor to find the version string.  
 	 */
 	private final CommandExecutor executor;
 
 	/**
 	 * Logs information on versions. 
 	 * Typically, just info are logged, 
 	 * but if a version could not be read or if a version is not as expected, 
 	 * also a warning is logged. 
 	 */
 	private final LogWrapper log;
 
 	/**
 	 * Creates meta info using an executor to find out the version 
 	 * and a logger to log warnings and infos, e.g. if a version does not fit the expectations. 
 	 * 
 	 * @param executor
 	 *    the executor to execute the converters to find out their version. 
 	 * @param log
 	 *    the logger to log info on versions. 
 	 */
 	MetaInfo(CommandExecutor executor, LogWrapper log) {
 		this.executor = executor;
 		this.log = log;
 	}
 
   // TBD: no general properties but class Coordinates 
   // This allows access without specifying keys as strings 
   /**
    * Returns the coordinates of this maven plugin as a properties. 
    *
    * @return
    *   The coordinates of this plugin with fields 
    *   'groupId', 'artifactId', 'version'. 
    * @throws BuildFailureException
    *   TMI01 if the stream to the according properties file could not be created 
    *   TMI02 if the properties could not be read. 
    */
   Coordinates getCoordinates() throws BuildFailureException {
     // may throw TMI01
     Properties properties = getProperties(COORDINATE_PROPERTY_FILE_NAME);
 		assert "[groupId, artifactId, version]".equals(properties
 					.stringPropertyNames().toString()) : "Found unexpected properties ";
     return new Coordinates(properties.getProperty("groupId"),
                            properties.getProperty("artifactId"),
                            properties.getProperty("version"));
   }
 
   /**
    * The string 'version' to be inserted in a warning 
    * that the version of a converter is not in the expected range. 
    * TBD: more precise information. 
    * Is invoked in {@link #versionLine(String, String, boolean, String, String, String)} 
    * but only in the context where this is needed for clarification. 
    */
   private final static String VERSION_QUOTE = "version ";
 
 	// CAUTION, depends on the maven-jar-plugin and its version 
 	/**
 	 * Prints meta information, mainly version information 
 	 * on this software and on the converters and checker tools used. 
 	 * <p>
 	 * WMI01: If the version string of a converter cannot be read. 
 	 * WMI02: If the version of a converter is not as expected. 
 	 *
 	 * @param includeVersionInfo
 	 *    whether to include plain version info; else warnings only.
    * @param convertersExcluded
    *    set of excluded converters. 
 	 * @return
 	 *    whether a warning has been issued. 
 	 * @throws BuildFailureException
 	 *    <ul>
 	 *    <li>TMI01: if the stream to either the manifest file 
 	 *        or to a property file, either {@LINK #VERSION_PROPS_FILE} 
 	 *        or {@link MetaInfo.GitProperties#GIT_PROPS_FILE} 
 	 *           could not be created. </li>
 	 *    <li>TMI02: if the properties could not be read 
 	 *        from one of the two property files mentioned above. </li>
    *    <li>TMI03: the manifest file is not readable although the stream is ok. </li>
 	 *    <li>TSS05: if converters are excluded in the pom which are not known. </li>
 	 *    </ul>
 	 */
 	public boolean printMetaInfo(final boolean includeVersionInfo,
                               SortedSet<Converter> convertersExcluded)
 			throws BuildFailureException {
 
 		if (includeVersionInfo) {
       // may throw TMI01, TMI03
 			ManifestInfo manifestInfo = new ManifestInfo();
 			// TBC: how does maven determine that version?? 
 			//String versionMf = manifestInfo.getImplVersion();
 			//System.out.println("mf version: '" + versionMf + "'");
 			this.log.info("Manifest properties: ");
 			for (String line : manifestInfo.toStringArr()) {
 				this.log.info(line);
 			}
 
 			//String mavenDir = META_FOLDER + "maven/";
 			//URL url = MetaInfo.class.getClassLoader().getResource(mavenDir);
 			//	try {
 			//	    //System.out.println("path: "+url);
 			//	    //System.out.println("path: "+url.toURI());
 			//	    //File[] files = new File(url.toURI()).listFiles();
 			//	    //System.out.println("cd maven; ls: "+java.util.Arrays.asList(files));
 			//	} catch (URISyntaxException e) {
 			//	    throw new IllegalStateException("Found unexpected type of url: "+url);
 			//	}
 			//String propertyFileName = META_FOLDER + "maven/" + "eu.simuline.m2latex/"
 			//		+ "latex-maven-plugin/" + "pom.properties";
 			this.log.info("pom properties: coordinates");
       // may throw TMI01, TMI02
 			Coordinates coords = getCoordinates();
 			this.log.info("groupId:    '" + coords.groupId + "'");
 			this.log.info("artifactId: '" + coords.artifactId + "'");
 			this.log.info("version:    '" + coords.version + "'");
 
 			//	propertyFileName = "META-INF/"
 			//	    + "maven/"
 			//	    + "eu.simuline.m2latex/"
 			//	    + "latex-maven-plugin/"
 			//	    + "pom.xml";
 			//	url = this.getClass().getClassLoader()
 			//	    .getResource(propertyFileName);
 			//	System.out.println("url:"+url);
 			//	MavenXpp3Reader reader = new MavenXpp3Reader();
 			//	Model model = reader.read(new InputStreamReader(url.openStream()));
 
 			GitProperties gitProperties = new GitProperties();
 			this.log.info("git properties: ");
 			gitProperties.log();
 			String gitBuildVersion = gitProperties.getBuildVersion();
 			//System.out.println("git.build.version: " + gitBuildVersion);
 			assert gitBuildVersion.equals(manifestInfo.getImplVersion());
 
 			//	String gitCommitIdDescribe = gitProperties.getCommitIdDescribe();
 			//	System.out.println("git.commit.id.describe: " + gitCommitIdDescribe);
 			//	String gitBuildTime = gitProperties.getBuildTime();
 			//	System.out.println("git.build.time: " + gitBuildTime);
 
 			// TBD: rework; this is just the beginning 
 			//	System.out.println("version properties of converters: ");
 			//	Properties properties = getProperties("version.properties");
 			//
 			//	System.out.println("version.makeindex:"
 			//		   +properties.getProperty("version.makeindex"));
 
 			// headlines 
 			this.log.info("tool versions: ");
       // Note that 
       // "?warning? " in the headline lines up with 
       // "          " the placeholder if no warning occurs. 
       // Both are preceeded by "[INFO] "
       // Also, 
       // " W"
 			this.log.info(versionLine("?warning? ", "command",
 					includeVersionInfo, "actual version", "(not)in",
 					"[expected version interval]"));
 		}
 
 		Properties versionProperties = getProperties(VERSION_PROPS_FILE);
 		if (versionProperties.size() > Converter.values().length) {
 			// Relation < need not be checked since all converters are checked below 
 			throw new IllegalStateException("Number of version properties "
 					+ versionProperties.size() + " does not fit number of converters "
 					+ Converter.values().length + ". ");
 		}
 
 		boolean doWarnAny = false;
 		// may throw BuildFailureException TSS05
 		// SortedSet<Converter> convertersExcluded =
 		// 		this.settings.getConvertersExcluded();
 		// collects converters not found but also not excluded. 
 		SortedSet<Converter> convertersNotFound = new TreeSet<Converter>();
 		// TBD: try to deal with makeindex using stdin instead of dummy file: 
 		// InputStream sysInBackup = System.in;
     for (Converter conv : Converter.values()) {
 			doWarnAny |= logConverterInfo(conv, includeVersionInfo, convertersExcluded, convertersNotFound, versionProperties);
 		} // for 
 
 		if (includeVersionInfo) {
 			// keep informed about excluded tools 
 			if (!convertersExcluded.isEmpty()) {
 				this.log.info("tools excluded: ");
 				this.log.info(Converter.toCommandsString(convertersExcluded));
 			}
 
 			// keep informed about included tools not found 
 			if (!convertersNotFound.isEmpty()) {
 				this.log.info("tools not found: ");
 				this.log.info(Converter.toCommandsString(convertersNotFound));
 			}
 		}
 		return doWarnAny;
 	}
 
   /**
    * Returns a so called version line describing the version of a converter named {@code cmdStr} 
    * if invoked by {@link #logConverterInfo(Converter, boolean, SortedSet, SortedSet, Properties)}. 
    * If {@code includeVersionInfo}, then the version lines form a table 
    * and this method is also used to create the header of this table 
    * which is the case if invoked by {@link #printMetaInfo(boolean, SortedSet)} directly. 
    * 
    * Except {@code includeVersionInfo} the parameters describe the columns of the table 
    * and so it is clear that if used to create the header, the values are quite special. 
 
    * It consists of 
    * a <code>warnStr</code> which may be a warning specifier or empty, either because it is not a warning 
    * or because the warning was displayed before (in case the version cannot be detected)
    * @param warnStr
    *    the warning string or the header of the warning column 
    *    The warning string is either {@code 'WMI02: '} indicating that the version of {@code cmdStr} does not fit the expectation, 
    *    or an empty string of appropriate length indicating that the version fits (in an {@code [INFO]} line), 
    *    or an empty string if the version cannot be determined. 
    *    In the latter case, warning {@code WMI01} is displayed in the line before clarifying the problem. 
    *    Thus no further warning indication is needed and the {@code warnStr} is empty. 
    *    On the other hand the line starts with {@code [WARNING]} so the empty {@code warnStr} is shorter than for an {@code [INFO]} line. 
    * @param cmdStr
    *    the name of the converter under consideration or the header of the command column. 
    * @param includeVersionInfo
    *    an indication whether this line is among lines displaying info also which means it is in a table, 
    *    possibly the header of that table. 
    *    Else for clarification of the context {@link #VERSION_QUOTE} is included. 
    * @param versionStr
    *    the version string of {@code cmdStr} or the header of the according column. 
    *    If the version of {@code cmdStr} cannot be determined, it is given by {@link MetaInfo.Version#VERSION_UNKNOWN}. 
    * @param inclStr
    *    the string {@code not?in} or in the context of the header, 
    *    {@code in} if the version of {@code cmdStr} is known to be in range, 
    *    {@code not in} if the version of {@code cmdStr} is known to be not in range, 
    *    {@code not?in} if it is unknown whether the version of {@code cmdStr} is in range, 
    * @param expVersionInterval
    *    the interval of allowed versions of {@code cmdStr} or in the context of the header. 
    * @return
    *    the version line of a converter {@code cmdStr} or the header of the table of version lines. 
    */
   private static String versionLine(String warnStr, String cmdStr, boolean includeVersionInfo, 
         String versionStr, String inclStr, String expVersionInterval) {
     return String.format(TOOL_VERSION_FORMAT, warnStr, cmdStr+":",
 					includeVersionInfo ? "" : VERSION_QUOTE, versionStr, inclStr, expVersionInterval);
   }
 
   /**
    * Logs info or warning on the given converter 
    * and returns whether a warning was emitted; else it was an info line or nothing at all. 
    * 
    * @param conv
    *    The converter under consideration. 
    * @param includeVersionInfo
 	 *    whether to include plain version info; else warnings only.
    * @param convertersExcluded
    *    set of excluded converters. 
    * @param convertersNotFound
    *    to collect the set of converters not found. 
    *    This shall be empty when invoking this method. 
    * @param versionProperties
    *    The properties describing the allowed version intervals 
    *    for all registered converters. 
    * @return
 	 *    whether a warning has been logged. 
    * @throws BuildFailureException
    *    TBD
    */
   private boolean logConverterInfo(Converter conv,
         boolean includeVersionInfo,
         SortedSet<Converter> convertersExcluded,
         SortedSet<Converter> convertersNotFound,
         Properties versionProperties) throws BuildFailureException {
 
     assert(convertersNotFound.isEmpty());
     if (convertersExcluded.contains(conv)) {
       // Note that for excluded converters, no warnings are emitted.
       return false;
     }
 
     // System.setIn(new ByteArrayInputStream("\u0004\n".getBytes()));
     String cmdStr = conv.getCommand();
 
     CmdResult resultWhich = this.executor.executeEmptyEnv(TexFileUtils.getEmptyIdx().getParentFile(),
         null,
         CMD_WHICH,
         CommandExecutor.ReturnCodeChecker.Never,
         new String[] { cmdStr });
     if (resultWhich.returnCode == 1) {
       // skip if command cmd is unknown to command which.
       // Note that converters which are not accessible (typically not installed)
       // do not cause warnings here, because when using them, the situation is pretty
       // clear.
       // This is different for unexpected behavior caused by version not taken into
       // account.
       // Nevertheless, the converters not found are listed as an information,
       // as the excluded are.
       convertersNotFound.add(conv);
       return false;
     }
 
     // get actual version of the converter and expected version interval
     Version actVersionObj = new Version(conv, this.executor);
     String expVersionStr = versionProperties.getProperty(cmdStr);
     VersionInterval expVersionInterval = new VersionInterval(conv, expVersionStr);
 
     String warnStr, inclStr;
     boolean doWarn = false;
     if (actVersionObj.isMatching()) {
       // Here, we can find out, 
       // whether the version of the converter fits the interval 
       doWarn = !expVersionInterval.contains(actVersionObj);
       if (doWarn) {
         inclStr = "not in";
         warnStr = "WMI02: ";
       } else {
         // Here is the only branch, where no warning is logged. 
         if (!includeVersionInfo) {
           return false;
         }
         // Here, an INFO must be logged. 
         // "[WARNING] WMIxx: " and 
         // "[INFO]           " must line up. 
         warnStr = "          ";
         // warnStr is the sting after "[INFO] "
         inclStr = "in";
       }
     } else {
       // Here, we cannot find out, 
       // whether the version of the converter fits the interval 
       doWarn = true;
       this.log.warn("WMI01: Version string from converter " + conv
           + " did not match expected form: \n" + actVersionObj.getText());
       inclStr = "not?in";
       // no warning number, still the above is valid 
       // and so this line is a warning (doWarn=true) 
       // The warn string must line up with 
       // "[WARNING] WMI01: ", means have the same length as "WMI01: "
       warnStr =    "       ";
     }
 
     String logMsg = versionLine(warnStr, cmdStr, includeVersionInfo, 
         actVersionObj.getString(), inclStr, expVersionStr);
     // this.log.info("actVersion: "+actVersionObj.getSegments());
     // this.log.info("expVersion: "+expVersionObj.getSegments());
     // this.log.info("actVersion: "+actVersionObj.getSegmentsAsStrings());
     // this.log.info("expVersion: "+expVersionObj.getSegmentsAsStrings());
     // this.log.info("actVersion?expVersion:
     // "+actVersionObj.compareTo(expVersionObj));
     if (doWarn) {
       this.log.warn(logMsg);
     } else {
       this.log.info(logMsg);
     }
     return doWarn;
   } // treatConverter
 
 }