/*
 * Created on Sep 21, 2004
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Generation - Code and Comments
 */
package org.eclipse.wst.xsd.ui.internal.refactor.util;


import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import org.eclipse.wst.common.uriresolver.internal.URI;
import org.eclipse.wst.sse.core.internal.util.PathHelper;


/**
 * Hyperlink manager. Proved useful services like link conversion
 * An utility class to help other parsre modules to convert links
 */
public class LinkURLHelper {

	private static final String FILE_PROTOCOL_SEARCH_SIG = "file:/";//$NON-NLS-1$
	private static final String FILE_PROTOCOL_SIG = "file:///";//$NON-NLS-1$
	private static String RELATIVE_PATH_SIG = "..";//$NON-NLS-1$	
	private static final String FORWARD_SLASH = "/";//$NON-NLS-1$	
	private URL fBaseUrl = null; // base url. assumed to a absulute url
	private String fBaseUrlString = null;
	private URL fDocRoot = null;
	private String fDocRootString = null;

	public LinkURLHelper(String baseUrl) {
		initialize(baseUrl, null);
	}


	public LinkURLHelper(String baseUrl, String docRoot) {
		initialize(baseUrl, docRoot);
	}

	/**
	 * Special adujust for file url
	 */
	public String adjustFileProtocolUrl(String url) {
		if (url.startsWith(FILE_PROTOCOL_SEARCH_SIG)) {
			url = FILE_PROTOCOL_SIG + url.substring(FILE_PROTOCOL_SEARCH_SIG.length());
		}
		return url;
	}

	private String convert(String url, URL baseUrl, String urlString) {
		String absUrl = url;
		if (baseUrl != null) {
			try {
				// do special thing file protocol
				if (baseUrl.getProtocol().equalsIgnoreCase("file")) {//$NON-NLS-1$
					// remove the fist
					if (url.startsWith("/"))//$NON-NLS-1$
						url = url.substring(1);
					// empty string causes malformed exception	
					String tempUrl = url;
					if ("".equals(url))//$NON-NLS-1$
						tempUrl = " ";//$NON-NLS-1$
					URL newUrl = new URL(baseUrl, tempUrl);
					// do extra math for file protocol to support ie based
					absUrl = adjustFileProtocolUrl(newUrl.toString());
				}
				else {
					URL newUrl = new URL(fBaseUrl, url);
					absUrl = newUrl.toString();
				}
			}
			catch (MalformedURLException me) {
			}
			// convert everything to forward slash
			absUrl = PathHelper.switchToForwardSlashes(absUrl);
		}
		else {
			// the given may be based on file
			if (urlString != null) {
				// swich the url to proper direction
				url = PathHelper.removeLeadingSeparator(url);
				File fle = new File(urlString, url);
				absUrl = fle.getPath();

			}
			// convert everything to forward slash
			absUrl = PathHelper.switchToForwardSlashes(absUrl);

			// if the path ends with ".." we need to add a terminating slash or 
			// else the link will not be resolved correctly.  (it will look like
			// /url/path/to/somewhere/.. instead of /url/path/to/
			if (absUrl.endsWith(FORWARD_SLASH + RELATIVE_PATH_SIG)) {
				absUrl += FORWARD_SLASH;
			}
		}

		// resolve relative path to absolute
		absUrl = PathHelper.adjustPath(absUrl);
		return absUrl;
	}

	private void initialize(String baseUrl, String docRoot) {
		//
		// Find out whether baes url is a url or file name
		//
		if ( URI.validScheme(baseUrl) ) {
			try {
				String temp = PathHelper.appendTrailingURLSlash(baseUrl);
				fBaseUrl = new URL(temp);
			}
			catch (MalformedURLException mue) {
				// it is a file based url
				fBaseUrlString = baseUrl;
			}
		}
		else {
			// it is a file based url
			fBaseUrlString = baseUrl;
		}

		// do the same for doc root
		if (docRoot != null) {
			if ( URI.validScheme(docRoot) ) {
				try {
					String temp = PathHelper.appendTrailingURLSlash(docRoot);
					fDocRoot = new URL(temp);
	
				}
				catch (MalformedURLException mue) {
					// it is a file based url
					fDocRootString = docRoot;
				}
			}
			else {
				// it is a file based url
				fDocRootString = docRoot;
			}
		}
	}

	/**
	 *  Convert the given url to a abolute url using the base url
	 *  Input url can be of any othe following format
	 * Absolute urls
	 * --------------
	 *  . http://www.foo.com/
	 *  . http://www.foo.com
	 *  . http://www.foo.com/folder
	 *  . http://www.foo.com/folder/
	 *  . http://www.foo.com/index.html
	 *  . http://www.foo.com/folder/index.html
	 *  . http://www.foo.com/folder/../index.html
	 * Url relative  on document root
	 * -------------------------
	 *  . /
	 *  . /folder
	 *  . /index.html
	 *  . /folder/index.html
	 *  . /folder/../index.html
	 * 
	 * Self relative
	 * -------------------------
	 *  . index.html
	 *  . ./index.html
	 *  . ../index.html
	 *  . folder/index.html
	 *  . folder/../index.html
	 *
	 * file based url adds another dimension since it doesn't have a document root
	 * So uses fDocRoot if provided
	 */
	public String toAbsolute(String url) {
		String absUrl = url;

		URL newUrl = null;
		// try to see it is a absolute url
		if ( URI.validScheme(url) ) {
			try {
				newUrl = new URL(url);
			}
			catch (MalformedURLException me) {
			}
		}
		// if document root is provided
		// do special case
		if (newUrl == null) {
			if (fDocRoot == null && fDocRootString == null) {
				// try to check relative url
				absUrl = convert(url, fBaseUrl, fBaseUrlString);
			}
			else {
				// doc root is provided
				// if the url is a doc root based use doc root

				if (url.startsWith("/"))//$NON-NLS-1$
					absUrl = convert(url, fDocRoot, fDocRootString);
				else
					absUrl = convert(url, fBaseUrl, fBaseUrlString);

			}
		}
		return absUrl;
	}

	/**
	 * Convert from an absolute url to relative url based on the given url
	 * Both are assumed to be ablsute url
	 */
	public String toRelative(String url, String documentUrl) {
		String output = url;
		// assuming both urls are absolute
		try {
			URL inputUrl = new URL(url);
			URL docUrl = new URL(documentUrl);
			// filter out if the urls are not fro the same domain
			if (!inputUrl.getProtocol().equals(docUrl.getProtocol()) || !inputUrl.getHost().equals(docUrl.getHost()) || inputUrl.getPort() != docUrl.getPort())
				return output;
			// both url are coming form the same place
			// strip off the domain parts
			String inputName = inputUrl.getFile();
			String docName = docUrl.getFile();
			output = PathHelper.convertToRelative(inputName, docName);
		}
		catch (MalformedURLException me) {
			output = null;
		}
		return output;
	}

//	/*
//	 */
//	protected  String getScheme(String passedSpec) {
//		if (passedSpec != null) {
//	
//			final String spec = passedSpec.trim();
//			
//			// protocol(scheme) java.net.URL can recognize is detemined
//			// what URL.getURLStreamHandle(protocol) returns.
//			// in Eclipse, only :
//			//		valoader:
//			//		file:
//			//		jar:
//			//		platform:
//			//		doc:
//			//		ftp:
//			//		gopher:
//			//		http:
//			//		mailto:
//			//		netdoc:
//			//		systemresource:
//			//		verbatim:
//			// can recognize. Otherwise, it throws exception...
//			// the following code comes from hpbcom/url.cpp, Url::parse_protocol()
//			final int limit = spec.length();
//			String newProtocol = null;
//			for( int index = 0; index < limit; index++ ) {
//				final char p = spec.charAt(index);
//				if (p == '/') {
//					break;
//				}
//				if (p == ':') {
//					newProtocol = spec.substring(0, index);
//					break;
//				}
//			}
//			// copy end
//		
//			 			
//			if (newProtocol != null && newProtocol.length() > 1 ) {
//				for ( int i = 0; i < PROTOCOLS.length; i++ ){
//					if (newProtocol.compareToIgnoreCase(PROTOCOLS[i]) == 0) {
//						// matched;
//						return newProtocol;
//					}
//				}
//			}
//		}
//		//i don't know what is newProtocol. Ask URI class itself.
//		//No, calling URI again is very slow. So, just give up
//		//URI uri = new URI(spec);
//		//return uri.getScheme();
//		return null;//$NON-NLS-1$
//	}
}