/* ExtendletLoader.java

	Purpose:
		
	Description:
		
	History:
		Wed May 28 17:01:32     2008, Created by tomyeh

Copyright (C) 2008 Potix Corporation. All Rights Reserved.

{{IS_RIGHT
	This program is distributed under LGPL Version 2.1 in the hope that
	it will be useful, but WITHOUT ANY WARRANTY.
}}IS_RIGHT
*/
package org.zkoss.web.util.resource;

import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.zkoss.io.Files;
import org.zkoss.lang.Library;
import org.zkoss.util.resource.Loader;

/**
 * A skeletal implementation of the loader used to implement an extendlet.
 * All you have to do is to implement {@link #parse}
 * and {@link #getExtendletContext}.
 *
 * <p>If the real path is not the same as the path specified in URL,
 * you can override {@link #getRealPath}.
 *
 * @author tomyeh
 * @see Extendlet
 * @since 3.0.6
 */
public abstract class ExtendletLoader<V> implements Loader<String, V> {
	private static final Logger log = LoggerFactory.getLogger(ExtendletLoader.class);

	private int _checkPeriod;

	protected ExtendletLoader() {
		_checkPeriod = getInitCheckPeriod();
	}

	/** Returns the real path for the specified path.
	 *
	 * <p>Default: return path, i.e., the path specified in URL is
	 * the real path.
	 *
	 * <p>Notice that {@link #parse} will receive the original path
	 * (rather than the returned path).
	 *
	 * @param path the path specified in URL.
	 * Notice that it does NOT start with "~./". Rather it starts with
	 * "/". For example, "/zul/css/zk.wcs".
	 * @since 5.0.0
	 */
	protected String getRealPath(String path) {
		return path;
	}

	//Loader//
	public boolean shallCheck(String src, long expiredMillis) {
		return expiredMillis > 0;
	}

	/** Returns the last modified time.
	 */
	public long getLastModified(String src) {
		if (getCheckPeriod() < 0)
			return 1; //any value (because it is not dynamic)

		URLConnection conn = null;
		try {
			URL url = getExtendletContext().getResource(src);
			if (url != null) {
				// prevent SSRF warning
				url = new URL(url.getProtocol(), url.getHost(), url.getPort(), url.getFile());
				conn = url.openConnection();
				final long v = conn.getLastModified();
				return v != -1 ? v : 0; //not to reload (5.0.6 for better performance)
			}
		} catch (Throwable ex) {
			// expected
		} finally {
			if (conn != null) {
				try {
					conn.getInputStream().close();
				} catch (Throwable e) {
					log.warn("The connection cannot be closed", e);
				}
			}
		}
		return -1; //reload (might be removed)
	}

	public V load(String src) throws Exception {
		if (log.isDebugEnabled())
			log.debug("Parse " + src);
		final String path = getRealPath(src);
		InputStream is = null;
		if (getCheckPeriod() >= 0) {
			//Due to Web server might cache the result, we use URL if possible
			try {
				URL real = getExtendletContext().getResource(path);
				if (real != null) {
					// prevent SSRF warning
					real = new URL(real.getProtocol(), real.getHost(),
							real.getPort(), real.getFile());
					is = real.openStream();
				}
			} catch (Throwable ex) {
				log.warn("Unable to read from URL: " + path, ex);
			}
		}

		if (is == null) {
			is = getExtendletContext().getResourceAsStream(path);
			if (is == null)
				return null;
		}

		try {
			return parse(is, path, src);
		} catch (Throwable ex) {
			log.error("Failed to parse " + src, ex);
			return null; //as non-existent
		} finally {
			Files.close(is);
		}
	}

	//Derive to override//
	/** It is called to parse the resource into an intermediate format
	 * depending on {@link Extendlet}.
	 *
	 * <p>The object is returned directly by {@link #load}, so
	 * you can return an instance of org.zkoss.util.resource.Loader.Resource
	 * to have more control on {@link org.zkoss.util.resource.ResourceCache}.
	 *
	 * @param is the content of the resource
	 * @param path the path of the resource.
	 * It is the value returned by {@link #getRealPath}, so called
	 * the real path
	 * @param orgpath the original path.
	 * It is the path passed to the <code>path</code> argument
	 * of {@link #getRealPath}. It is useful if you want to retrieve
	 * the additional information encoded into the URI.
	 * @since 5.0.0
	 */
	protected abstract V parse(InputStream is, String path, String orgpath) throws Exception;

	/** Returns the extendlet context.
	 */
	protected abstract ExtendletContext getExtendletContext();

	/** Returns the check period, or -1 if the content is never changed.
	 * Unit: milliseconds.
	 *
	 * <p>Default: It checks if an integer (unit: second) is assigned
	 * to a system property called org.zkoss.util.resource.extendlet.checkPeriod.
	 * If no such system property, -1 is assumed (never change).
	 * For the runtime environment the content is never changed,
	 * since all extendlet resources are packed in JAR files.
	 */
	public int getCheckPeriod() {
		return _checkPeriod;
	}

	private static int getInitCheckPeriod() {
		final int v = Library.getIntProperty("org.zkoss.util.resource.extendlet.checkPeriod", -1);
		return v > 0 ? v * 1000 : v;
	}
}
