/**
 * <copyright> Copyright 2006 by Know-Center, Graz, Austria </copyright>
 * PDF-AS has been contracted by the E-Government Innovation Center EGIZ, a
 * joint initiative of the Federal Chancellery Austria and Graz University of
 * Technology.
 *
 * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 * http://www.osor.eu/eupl/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing permissions and
 * limitations under the Licence.
 *
 * This product combines work with different licenses. See the "NOTICE" text
 * file for details on the various modules and licenses.
 * The "NOTICE" text file is part of the distribution. Any derivative works
 * that you distribute must include a readable copy of the "NOTICE" text file.
 */
package at.gv.egiz.pdfas.algorithmSuite;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * Utility for mapping signature and hash algorithms between URI and abbreviation.<br>
 * Supported algorithms are defined in external resource {@value #SUPPORTED_ALGORITHMS_RESOURCE}<br>
 * 
 * e.g. <code>sha1 <-> http://www.w3.org/2000/09/xmldsig#sha1</code>
 * 
 * @author dferbas
 *
 */

public class AlgorithmMapper {
	private static final String SUPPORTED_ALGORITHMS_RESOURCE = "supportedAlgorithms.txt";
	private static Map algorithmMap = new HashMap();
	private static Log log = LogFactory.getLog(AlgorithmMapper.class);

	/**
	 * read available algorithms from resource 
	 */
	static {
		try {
			log.debug("reading supported algorithms from " + SUPPORTED_ALGORITHMS_RESOURCE);
			List lines = IOUtils.readLines(AlgorithmMapper.class.getResourceAsStream(SUPPORTED_ALGORITHMS_RESOURCE));
			for (int i = 0; i < lines.size(); i++) {
				String uri = (String)lines.get(i);
				if (isValidLine(uri)) {
					String abbr = parseAbbreviation(uri);
					algorithmMap.put(abbr, uri);
					if (log.isDebugEnabled()) {
						log.debug("added supported algorithm: " + abbr + "=" + uri);
					}
				}
			}
		} catch (IOException e) {
			throw new RuntimeException("error loading supportetAlgorithms.properties file", e);
		}
	}

	/**
	 * Get algorithm abbreviation (equals last part after namespace#) from uri<br>
	 * 
	 * e.g. <code>sha1 from http://www.w3.org/2000/09/xmldsig#sha1</code>
	 * 
	 * @param algorithmUri algorithm URI
	 * @return algorithm abbreviation
	 */
	public static String getAbbreviation(String algorithmUri) {
		if (!algorithmMap.containsValue(algorithmUri)) {
			throw new RuntimeException("unsupported Algorithm " + algorithmUri);
		}
		return parseAbbreviation(algorithmUri);
	}

	private static boolean isValidLine(String uri) {
		if (uri == null || uri.length() == 0) return false;
		if (uri.trim().startsWith("#")) return false;
		return true;
	}

	/**
	 * Get valid URI from algorithm abbreviation<br>
	 * 
	 * e.g. <code>http://www.w3.org/2000/09/xmldsig#sha1 from sha1</code>
	 * 
	 * @param algorithmShort
	 * @return URI
	 */
	public static String getUri(String algorithmShort) {
		if (!algorithmMap.containsKey(algorithmShort)) {
			throw new RuntimeException("unsupported Algorithm " + algorithmShort);
		}
		return (String)algorithmMap.get(algorithmShort);
	}

	/**
	 * Get hash (abbreviation) from signature method (eg. sha1 from ecdsa-sha1).
	 * @param suite abbreviation or full qualified signature method
	 * @return digest method abbreviation
	 */
	public static String getHashAbbrFromSuite(String suite) {
		try {
			int pos = suite.lastIndexOf('-');
			return suite.substring(pos + 1);
		} catch (Exception e) {
			throw new RuntimeException("cannot parse algorithm string for hash method: " + suite);
		}
	}

	/**
	 * 
    * Get hash method (URI) from signature method
    * @param suite abbreviation or full qualified signature method
    * @return digest method URI
    *
	 */
	public static String getHashUriFromSuite(String suite) {
		return getUri(getHashAbbrFromSuite(suite));
	}

	private static String parseAbbreviation(String algorithmUri) {
		try {
			int pos = algorithmUri.lastIndexOf('#');
			return algorithmUri.substring(pos + 1);
		} catch (Exception e) {
			throw new RuntimeException("invalid algorithm entry in " + SUPPORTED_ALGORITHMS_RESOURCE
					+ ": " + algorithmUri);
		}
	}

}