/*******************************************************************************
 * Copyright (c) 2001, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Jens Lukowski/Innoopract - initial renaming/restructuring
 *     
 *******************************************************************************/
package org.eclipse.wst.sse.core.internal.encoding;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.charset.IllegalCharsetNameException;
import java.util.Properties;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.content.IContentDescription;
import org.eclipse.wst.sse.core.internal.encoding.util.Assert;
import org.eclipse.wst.sse.core.internal.encoding.util.Logger;
import org.osgi.framework.Bundle;


public abstract class CodedIO {

	private final boolean DEBUG = false;
	
	public static final int MAX_BUF_SIZE = 1024 * 8;

	public static final int MAX_MARK_SIZE = MAX_BUF_SIZE;

	public static final String NO_SPEC_DEFAULT = "NoSpecDefault"; //$NON-NLS-1$

	private static Properties overridenCharsets = null;

	/**
	 * <p>
	 * There are two well known understood cases where the standard/default
	 * Java Mappings are not sufficient. (Thanks to Hirotaka Matsumoto for
	 * providing these two). I believe there are others that individual
	 * customers have requested to override on a case by case basis, but I've
	 * lost the details. TODO-future: document some of those use-cases.
	 * </p>
	 * <ul>
	 * <li>ISO-8859-8-I</li>
	 * <p>
	 * In the code conversion point of view, ISO-9959-8 and ISO-8859-8-I are
	 * the same. However. the representation on the browser is different. (
	 * It's very very hard to explain this into the words, but once you will
	 * see, you will understand it :) Many BiDi HTML/JSPs use ISO-8859-8-I in
	 * META/page directive. So WSAD needs to support this encoding.
	 * </p>
	 * <li>X-SJIS</li>
	 * <p>
	 * Because Mosaic/Navigator 2.0 supported only X-SJIS/X-EUC-JP, lots of
	 * old HTML files used X-SJIS/X-EUC-JP so that the customers still want us
	 * to support this code conversion for HTML files.
	 * </p>
	 * </ul>
	 * 
	 * @param detectedCharsetName
	 * @return the detectedCharsetName, if no overrides, otherwise the charset
	 *         name that should be used instead of detectedCharsetName
	 */
	/**
	 * This method is deliberatly 'default access' since clients should not
	 * need to access this information directly.
	 */
	static public String checkMappingOverrides(String detectedCharsetName) {
		// This method MUST return what was passed in, if
		// there are no
		// overrides.
		String result = detectedCharsetName;
		String newResult = getOverridenCharsets().getProperty(detectedCharsetName);
		if (newResult != null) {
			result = newResult;
		}
		return result;
	}

	/**
	 * Note: once this instance is created, trace info still needs to be
	 * appended by caller, depending on the context its created.
	 */
	public static EncodingMemento createEncodingMemento(byte[] detectedBom, String javaCharsetName, String detectedCharsetName, String unSupportedName, String specDefaultEncoding, String reason) {
		EncodingMemento result = new EncodingMemento();
		result.setJavaCharsetName(javaCharsetName);
		result.setDetectedCharsetName(detectedCharsetName);
		// TODO: if detectedCharset and spec default is
		// null, need to use "work
		// bench based" defaults.
		if (specDefaultEncoding == null)
			result.setAppropriateDefault(NO_SPEC_DEFAULT);
		else
			result.setAppropriateDefault(specDefaultEncoding);
		if (unSupportedName != null) {
			result.setInvalidEncoding(unSupportedName);
		}
		// check if valid
		try {
			Charset.isSupported(javaCharsetName);
		} catch (IllegalCharsetNameException e) {
			result.setInvalidEncoding(javaCharsetName);
		}

		// check UTF83ByteBOMUsed and UnicodeStream
		if (detectedBom != null) {
			if (detectedBom.length == 2)
				result.setUnicodeStream(true);
			else if (detectedBom.length == 3)
				result.setUTF83ByteBOMUsed(true);
		}
		return result;
	}

	/**
	 * Note: once this instance is created, trace info still needs to be
	 * appended by caller, depending on the context its created.
	 */
	public static EncodingMemento createEncodingMemento(String detectedCharsetName) {
		return createEncodingMemento(detectedCharsetName, null);
	}

	/**
	 * Note: once this instance is created, trace info still needs to be
	 * appended by caller, depending on the context its created.
	 */
	public static EncodingMemento createEncodingMemento(String detectedCharsetName, String reason) {
		return createEncodingMemento(detectedCharsetName, reason, null);
	}

	/**
	 * Note: once this instance is created, trace info still needs to be
	 * appended by caller, depending on the context its created.
	 */
	public static EncodingMemento createEncodingMemento(String detectedCharsetName, String reason, String specDefaultEncoding) {
		EncodingMemento result = new EncodingMemento();
		result = new EncodingMemento();
		String javaCharset = getAppropriateJavaCharset(detectedCharsetName);
		result.setJavaCharsetName(javaCharset);
		result.setDetectedCharsetName(detectedCharsetName);
		// TODO: if detectedCharset and spec default is
		// null, need to use "work
		// bench based" defaults.
		if (specDefaultEncoding == null)
			result.setAppropriateDefault(NO_SPEC_DEFAULT);
		else
			result.setAppropriateDefault(specDefaultEncoding);
		// check if valid
		try {
			Charset.isSupported(javaCharset);
		} catch (IllegalCharsetNameException e) {
			result.setInvalidEncoding(javaCharset);
		}

		return result;
	}

	/**
	 * This method can return null, if invalid charset name (in which case
	 * "appropriateDefault" should be used, if a name is really need for some
	 * "save anyway" cases).
	 * 
	 * @param detectedCharsetName
	 * @return
	 */
	public static String getAppropriateJavaCharset(String detectedCharsetName) {
		// we don't allow null argument (or risk NPE or
		// IllegalArgumentException later at several
		// points.
		Assert.isNotNull(detectedCharsetName, "illegal charset argument. it can not be null"); //$NON-NLS-1$
		String result = detectedCharsetName;
		// 1. Check explicit mapping overrides from
		// property file
		result = CodedIO.checkMappingOverrides(detectedCharsetName);
		// 2. Use the "canonical" name from JRE mappings
		// Note: see Charset JavaDoc, the name you get one
		// with can be alias,
		// the name you get back is "standard" name.
		Charset javaCharset = null;
		// Note: this will immediatly throw
		// "UnsuppotedCharsetException" if it
		// invalid. Issue: Is it more client friendly to
		// eat that exception and return null?
		javaCharset = Charset.forName(result);
		if (javaCharset != null) {
			result = javaCharset.name();
		}
		return result;
	}

	/**
	 * @return Returns the overridenCharsets.
	 */
	private static Properties getOverridenCharsets() {
		if (overridenCharsets == null) {
			overridenCharsets = new Properties();
			Bundle keyBundle = Platform.getBundle(ICodedResourcePlugin.ID);
			IPath keyPath = new Path("config/override.properties"); //$NON-NLS-1$
			URL location = Platform.find(keyBundle, keyPath);
			InputStream propertiesInputStream = null;
			try {
				propertiesInputStream = location.openStream();
				overridenCharsets.load(propertiesInputStream);
			} catch (IOException e) {
				// if can't read, just assume there's no
				// overrides
				// and repeated attempts will not occur,
				// since they
				// will be represented by an empty
				// Properties object
			}
		}
		return overridenCharsets;
	}

	/**
	 * This class need not be instantiated (though its subclasses can be).
	 */
	protected CodedIO() {
		super();
	}

	protected EncodingMemento createMemento(IContentDescription contentDescription) {
		EncodingMemento result;
		String appropriateDefault = contentDescription.getContentType().getDefaultCharset();
		String detectedCharset = (String) contentDescription.getProperty(IContentDescriptionExtended.DETECTED_CHARSET);
		String unSupportedCharset = (String) contentDescription.getProperty(IContentDescriptionExtended.UNSUPPORTED_CHARSET);
		String javaCharset = contentDescription.getCharset();
		// integrity checks for debugging
		if (javaCharset == null) {
			Logger.log(Logger.INFO_DEBUG, "charset equaled null!"); //$NON-NLS-1$
		} else if (javaCharset.length() == 0) {
			Logger.log(Logger.INFO_DEBUG, "charset equaled emptyString!"); //$NON-NLS-1$
		}
		byte[] BOM = (byte[]) contentDescription.getProperty(IContentDescription.BYTE_ORDER_MARK);
		//result = (EncodingMemento)
		// contentDescription.getProperty(IContentDescriptionExtended.ENCODING_MEMENTO);
		result = createEncodingMemento(BOM, javaCharset, detectedCharset, unSupportedCharset, appropriateDefault, null);
		if (!result.isValid()) {
			result.setAppropriateDefault(appropriateDefault);
			// integrity check for debugging "invalid" cases.
			// the apprriate default we have, should equal what's in the
			// detected field. (not sure this is always required)
			if (DEBUG && appropriateDefault != null && !appropriateDefault.equals(detectedCharset)) {
				Logger.log(Logger.INFO_DEBUG, "appropriate did not equal detected, as expected for invalid charset case"); //$NON-NLS-1$
			}
		}
		return result;
	}
}