/***
    *     Ambient - A music player for the Android platform
    Copyright (C) 2007 Martin Vysny
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  package sk.baka.ambient.commons;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.URL;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.NoSuchElementException;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.NotifyingInputStream;
  import sk.baka.ambient.R;
  import android.content.Context;
  
  /***
   * An abstract file cache, stores files into android application private
   * directory. Thread-safe. Essentially a singleton, there must be at most one
   * instance.
   * 
   * @author Martin Vysny
   */
  public class AbstractFileStorage {
  	/***
  	 * Set of names for which a file is available.
  	 */
  	private final Map<String, File> cache = new ConcurrentHashMap<String, File>();
  
  	/***
  	 * A read-only view of the cache.
  	 */
  	protected final Map<String, File> theCache = Collections
  			.unmodifiableMap(cache);
  
  	/***
  	 * Lengths of all files.
  	 */
  	private volatile long cacheSize = 0;
  
  	/***
  	 * All valid file extensions for this cache.
  	 */
  	private final Set<String> ext;
  
  	/***
  	 * describes content which this storage holds. Should form a correct
  	 * sentence with <code>"Downloading " + contentDesc + " failed"</code>.
  	 */
  	private final String contentDesc;
  
  	/***
  	 * Creates new cache instance.
  	 * 
  	 * @param ext
  	 *            a list of ".whatever" strings - valid extensions.
  	 * @param contentDesc
  	 *            describes content which this storage holds. Should form a
  	 *            correct sentence with
  	 *            <code>"Downloading " + contentDesc + " failed"</code>.
  	 */
  	public AbstractFileStorage(final String contentDesc, final String... ext) {
  		super();
  		this.contentDesc = contentDesc;
  		this.ext = new HashSet<String>(Arrays.asList(ext));
  		final String[] files = AmbientApplication.getInstance().fileList();
  		if (files != null) {
  			for (final String file : files) {
  				if (!supportsExtension(getExtension(file)))
  					continue;
  				final File f = AmbientApplication.getInstance()
  						.getFileStreamPath(file);
  				cache.put(getNameFromFile(file), f);
  				cacheSize += f.length();
  			}
  		}
 	}
 
 	/***
 	 * Checks if this storage supports given extension.
 	 * 
 	 * @param ext
 	 *            the ".extension" format
 	 * @return <code>true</code> if this storage supports such extensions,
 	 *         <code>false</code> otherwise.
 	 */
 	protected final boolean supportsExtension(final String ext) {
 		return this.ext.contains(ext);
 	}
 
 	private File getFileFromName(String name, String ext) {
 		final File result = AmbientApplication.getInstance().getFileStreamPath(
 				getFileNameFromName(name, ext));
 		return result;
 	}
 
 	private String getFileNameFromName(String name, String ext) {
 		// escape the name
 		String n = name.replace("_", "__");
 		n = n.replace("/", "_D");
 		n = n.replace("//", "_d");
 		return n + ext;
 	}
 
 	private String getExtension(String file) {
 		int extIndex = file.lastIndexOf('.');
 		if (extIndex < 0)
 			extIndex = file.length();
 		final String fileext = file.substring(extIndex);
 		return fileext;
 	}
 
 	private String getNameFromFile(String file) {
 		// un-escape the name
 		String f = file.replace("_D", "/");
 		f = f.replace("_d", "//");
 		f = f.replace("__", "_");
 		int extIndex = f.lastIndexOf('.');
 		if (extIndex < 0)
 			extIndex = f.length();
 		final String name = f.substring(0, extIndex);
 		return name;
 	}
 
 	/***
 	 * Maximum storage size, in bytes.
 	 */
 	protected long maxStorageSize = 256 * 1024;
 
 	/***
 	 * Sets maximum cache size, removing files if required.
 	 * 
 	 * @param maxCacheSize
 	 *            Maximum cache size, in bytes.
 	 */
 	public final void setMaxStorageSize(final long maxCacheSize) {
 		this.maxStorageSize = maxCacheSize;
 		cleanup();
 	}
 
 	/***
 	 * Returns <code>true</code> if this storage is full.
 	 * 
 	 * @return <code>true</code> if the size of all files in this storage
 	 *         exceeds {@link #setMaxStorageSize(long) maximum storage size}.
 	 */
 	public final synchronized boolean isFull() {
 		return cacheSize >= maxStorageSize;
 	}
 
 	/***
 	 * Cleans up old files. Superclass should implement a strategy to pick and
 	 * delete obsolete files. Default implementation does nothing. Called in
 	 * {@link #setMaxStorageSize(long)} method.
 	 */
 	protected void cleanup() {
 		// let overriding classes implement this method
 	}
 
 	/***
 	 * Registers a file to the cache. The file must exist. The file name must be
 	 * passable to the {@link Context#getFileStreamPath(String)} method.
 	 * 
 	 * @param name
 	 *            the file name, without the extension
 	 * @param ext
 	 *            the ".ext" string.
 	 * @return the name the file is registered under.
 	 * @throws FileNotFoundException
 	 *             if the file does not exist.
 	 */
 	protected final FileOutputStream createFile(final String name,
 			final String ext) throws FileNotFoundException {
 		checkExtension(ext);
 		return AmbientApplication.getInstance().openFileOutput(
 				getFileNameFromName(name, ext), Context.MODE_PRIVATE);
 	}
 
 	private void checkExtension(final String ext) {
 		if (!supportsExtension(ext)) {
 			throw new IllegalArgumentException("Unsupported extension: " + ext);
 		}
 	}
 
 	/***
 	 * Registers a file to the cache. The file must have been created using
 	 * {@link #createFile(String, String)}.
 	 * 
 	 * @param name
 	 *            the file name, without the extension
 	 * @param ext
 	 *            the ".ext" string.
 	 */
 	protected final void registerFile(final String name, final String ext) {
 		checkExtension(ext);
 		final File file = getFileFromName(name, ext);
 		cacheSize += file.length();
 		cache.put(name, file);
 	}
 
 	/***
 	 * Removes a file from the cache. The file must exist. The file name must be
 	 * passable to the {@link Context#getFileStreamPath(String)} method.
 	 * 
 	 * @param file
 	 *            the file
 	 */
 	protected final void removeFile(final File file) {
 		if (file.exists()) {
 			cacheSize -= file.length();
 			AmbientApplication.getInstance().deleteFile(file.getName());
 		}
 		cache.remove(getNameFromFile(file.getName()));
 	}
 
 	/***
 	 * Retrieves cached file.
 	 * 
 	 * @param name
 	 *            the name
 	 * @return File
 	 */
 	protected final File getCacheFile(final String name) {
 		final File result = getCacheFileNull(name);
 		if (result == null)
 			throw new IllegalArgumentException("No such file in cache: " + name);
 		return result;
 	}
 
 	/***
 	 * Retrieves cached file. May return <code>null</code> if no such file
 	 * exists.
 	 * 
 	 * @param name
 	 *            the name
 	 * @return File
 	 */
 	protected final File getCacheFileNull(final String name) {
 		return cache.get(name);
 	}
 
 	/***
 	 * Purges the cache - removes all cached files.
 	 */
 	public final synchronized void purge() {
 		for (final File file : cache.values()) {
 			cacheSize -= file.length();
 			AmbientApplication.getInstance().deleteFile(file.getName());
 		}
 		cache.clear();
 	}
 
 	/***
 	 * Returns a list of names of objects cached in this storage.
 	 * 
 	 * @return the storage.
 	 */
 	public Set<String> getNames() {
 		return theCache.keySet();
 	}
 
 	/***
 	 * Contains set of objects for which the file is currently being downloaded.
 	 */
 	private final ConcurrentMap<Object, Object> downloadQueue = new ConcurrentHashMap<Object, Object>();
 
 	/***
 	 * Each instance of the file storage should have its own download queue.
 	 */
 	private final Object taskType = new Object();
 
 	private final Runnable downloader = new Runnable() {
 		public void run() {
 			while (true) {
 				if (Thread.currentThread().isInterrupted()) {
 					return;
 				}
 				// grab random item
 				final Object fetchInfo;
 				try {
 					fetchInfo = downloadQueue.keySet().iterator().next();
 				} catch (final NoSuchElementException ex) {
 					// ugly, but thread-safe
 					return;
 				}
 				downloadQueue.remove(fetchInfo);
 				if (isProceedWithDownload(fetchInfo)) {
 					try {
 						fetchFileSync(fetchInfo);
 					} catch (Exception ex) {
 						throw new RuntimeException(ex.getMessage(), ex);
 					}
 				}
 			}
 		}
 	};
 
 	/***
 	 * Attempts to asynchronously download a file. Does nothing if the file is
 	 * already scheduled to be downloaded.
 	 * 
 	 * @param fetchInfo
 	 *            contains information on how to fetch the file.
 	 *            {@link #toURL(Object)} is called asynchronously to convert the
 	 *            fetch info object to an URL. This object must comply to the
 	 *            contract imposed on a {@link Map} key.
 	 */
 	protected final void fetchFileAsync(final Object fetchInfo) {
 		if (closing)
 			return;
 		if (downloadQueue.putIfAbsent(fetchInfo, MiscUtils.NULL) != null)
 			return;
 		final boolean isScheduled = AmbientApplication.getInstance()
 				.getBackgroundTasks().schedule(
 						downloader,
 						taskType,
 						true,
 						AmbientApplication.getInstance().getString(
 								R.string.downloading)
 								+ " " + contentDesc);
 		if (!isScheduled) {
 			downloadQueue.clear();
 		}
 	}
 
 	private volatile boolean closing = false;
 
 	/***
 	 * Converts given fetch info to an URL object. Default implementation throws
 	 * {@link UnsupportedOperationException}. Must be thread-safe as it is not
 	 * invoked from a Handler thread.
 	 * 
 	 * @param fetchInfo
 	 *            the fetch info object, never <code>null</code>.
 	 * @return URL which is used to download the file contents. If
 	 *         <code>null</code> then this download is aborted.
 	 * @throws IOException
 	 *             if i/o error occurs
 	 */
 	protected URL toURL(final Object fetchInfo) throws IOException {
 		throw new UnsupportedOperationException("unimplemented");
 	}
 
 	/***
 	 * Invoked before the download process starts. Must be thread-safe as it is
 	 * not invoked from a Handler thread.
 	 * 
 	 * @param fetchInfo
 	 *            the fetch info object, never <code>null</code>.
 	 * @return if <code>false</code> then this download is aborted.
 	 */
 	protected boolean isProceedWithDownload(final Object fetchInfo) {
 		return true;
 	}
 
 	/***
 	 * Closes the cache object, stopping any pending download operations.
 	 */
 	public void close() {
 		closing = true;
 		downloadQueue.clear();
 	}
 
 	private void fetchFileSync(final Object fetchInfo) throws IOException {
 		if (Thread.currentThread().isInterrupted())
 			return;
 		final URL url = toURL(fetchInfo);
 		if (url == null) {
 			// no url, bail out
 			onFileDownloaded(null, fetchInfo, false);
 			return;
 		}
 		if (Thread.currentThread().isInterrupted()) {
 			return;
 		}
 		final String[] filename = getFilenameAndExt(url, fetchInfo);
 		if (filename != null) {
 			final InputStream in = NotifyingInputStream.fromURL(url, 3,
 					AmbientApplication.getInstance().getString(
 							R.string.downloading)
 							+ " " + contentDesc);
 			IOUtils.copy(in, createFile(filename[0], filename[1]), 1024);
 			registerFile(filename[0], filename[1]);
 			onFileDownloaded(url, fetchInfo, true);
 		}
 	}
 
 	/***
 	 * The file was downloaded and is already registered in the storage. Default
 	 * implementation does nothing. Must be thread-safe as it is not invoked
 	 * from a Handler thread.
 	 * 
 	 * @param url
 	 *            the source URL
 	 * @param fetchInfo
 	 *            the fetch info object
 	 * @param success
 	 *            if <code>true</code> then the file is available in the cache.
 	 *            If <code>false</code> then the download process was aborted (
 	 *            {@link #toURL(Object)} returned <code>null</code>).
 	 */
 	protected void onFileDownloaded(final URL url, final Object fetchInfo,
 			final boolean success) {
 		// do nothing.
 	}
 
 	/***
 	 * Retrieves target file name. Default implementation throws
 	 * {@link UnsupportedOperationException}. Must be thread-safe as it is not
 	 * invoked from a Handler thread.
 	 * 
 	 * @param url
 	 *            the source URL. May be <code>null</code> - in this case the
 	 *            extension is not needed and returned extension may be
 	 *            <code>null</code> or the result may contain only the name.
 	 * @param fetchInfo
 	 *            the fetch info object
 	 * @return array containing two items - filename and extension. The
 	 *         extension must start with a dot. If <code>null</code> is returned
 	 *         then the object is not downloadable nor storable into the
 	 *         storage.
 	 */
 	protected String[] getFilenameAndExt(final URL url, final Object fetchInfo) {
 		throw new UnsupportedOperationException("unimplemented");
 	}
 
 	/***
 	 * Fetches a file. Attempts to fetch it from the internet if the file is not
 	 * found and we are online - in this case a background thread is run and the
 	 * method returns <code>null</code>.
 	 * 
 	 * @param fetchInfo
 	 *            the fetch info object
 	 * @return file or <code>null</code> if we are unable to provide any file
 	 *         now.
 	 */
 	protected File getFile(final Object fetchInfo) {
 		final String[] nameAndExt = getFilenameAndExt(null, fetchInfo);
 		if (nameAndExt == null)
 			return null;
 		// first, try the cache
 		final File file = theCache.get(nameAndExt[0]);
 		if (file != null)
 			return file;
 		fetchFileAsync(fetchInfo);
 		return null;
 	}
 }